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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Astronaut"(s) SELECT DISTINCT t0.s FROM "dbrdf_Astronaut_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Astronaut_delta_old";
        INSERT INTO "dbrdf_Astronaut_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Astronaut_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Astronaut_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_crew_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_crew_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_crew" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_crew_delta_old" ON "dbrdf_crew_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_crew_delta_old" ON "dbrdf_crew_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_crew_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_crew"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_crew_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_crew_delta_old";
        INSERT INTO "dbrdf_crew_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_crew_delta_new" t0;
        TRUNCATE TABLE "dbrdf_crew_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1173
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfVehicles_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfVehicles_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfVehicles" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfVehicles_delta_old" ON "dbrdf_numberOfVehicles_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfVehicles_delta_old" ON "dbrdf_numberOfVehicles_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfVehicles_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_numberOfVehicles"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfVehicles_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_numberOfVehicles_delta_old";
        INSERT INTO "dbrdf_numberOfVehicles_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfVehicles_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfVehicles_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1174
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_developer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_developer_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_developer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_developer_delta_old" ON "dbrdf_developer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_developer_delta_old" ON "dbrdf_developer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_developer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_developer"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_developer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_developer_delta_old";
        INSERT INTO "dbrdf_developer_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_developer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_developer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1175
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_soccerTournamentTopScorer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_soccerTournamentTopScorer_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_soccerTournamentTopScorer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_soccerTournamentTopScorer_delta_old" ON "dbrdf_soccerTournamentTopScorer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_soccerTournamentTopScorer_delta_old" ON "dbrdf_soccerTournamentTopScorer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_soccerTournamentTopScorer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_soccerTournamentTopScorer"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_soccerTournamentTopScorer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_soccerTournamentTopScorer_delta_old";
        INSERT INTO "dbrdf_soccerTournamentTopScorer_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_soccerTournamentTopScorer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_soccerTournamentTopScorer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1176
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_barPassRate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_barPassRate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_barPassRate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_barPassRate_delta_old" ON "dbrdf_barPassRate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_barPassRate_delta_old" ON "dbrdf_barPassRate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_barPassRate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_barPassRate"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_barPassRate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_barPassRate_delta_old";
        INSERT INTO "dbrdf_barPassRate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_barPassRate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_barPassRate_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1177
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Bird"(s) SELECT DISTINCT t0.s FROM "dbrdf_Bird_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Bird_delta_old";
        INSERT INTO "dbrdf_Bird_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Bird_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Bird_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1178
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_iobdbId_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_iobdbId_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_iobdbId" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_iobdbId_delta_old" ON "dbrdf_iobdbId_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_iobdbId_delta_old" ON "dbrdf_iobdbId_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_iobdbId_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_iobdbId"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_iobdbId_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_iobdbId_delta_old";
        INSERT INTO "dbrdf_iobdbId_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_iobdbId_delta_new" t0;
        TRUNCATE TABLE "dbrdf_iobdbId_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1179
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_operator_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_operator_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_operator" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_operator_delta_old" ON "dbrdf_operator_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_operator_delta_old" ON "dbrdf_operator_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_operator_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_operator"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_operator_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_operator_delta_old";
        INSERT INTO "dbrdf_operator_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_operator_delta_new" t0;
        TRUNCATE TABLE "dbrdf_operator_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1180
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_place_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_place_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_place" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_place_delta_old" ON "dbrdf_place_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_place_delta_old" ON "dbrdf_place_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_place_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_place"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_place_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_place_delta_old";
        INSERT INTO "dbrdf_place_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_place_delta_new" t0;
        TRUNCATE TABLE "dbrdf_place_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1181
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_averageSpeed1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_averageSpeed_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_averageSpeed_delta_old1";
        INSERT INTO "dbrdf_averageSpeed_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_averageSpeed_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_averageSpeed_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1182
    ---- DEPENDS ON: 296, 270, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Song>(?X) :- <http://dbpedia.org/ontology/EurovisionSongContestEntry>(?X) .
    INSERT INTO "dbrdf_Song"(s) SELECT t0.s FROM "dbrdf_EurovisionSongContestEntry" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Song" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/Song>(?X) :- <http://dbpedia.org/ontology/trackNumber>(?X,?X1) .
    INSERT INTO "dbrdf_Song"(s) SELECT DISTINCT t0.s FROM "dbrdf_trackNumber" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Song" 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_Song_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Song_delta_old"(s) SELECT t0.s FROM "dbrdf_Song" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Song_delta_old" ON "dbrdf_Song_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Song_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_MusicRecording_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_MusicRecording_delta_old"(s) SELECT t0.s FROM "dbrdf_MusicRecording" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_MusicRecording_delta_old" ON "dbrdf_MusicRecording_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_MusicRecording_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/Song$delta_new>(?X) :- <http://schema.org/MusicRecording$delta_old>(?X) .
        INSERT INTO "dbrdf_Song_delta_new"(s) SELECT t0.s FROM "dbrdf_MusicRecording_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Song" ex WHERE ex.s = t0.s);


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


        -- <http://schema.org/MusicRecording$delta_new>(?X) :- <http://dbpedia.org/ontology/Song$delta_old>(?X) .
        INSERT INTO "dbrdf_MusicRecording_delta_new"(s) SELECT t0.s FROM "dbrdf_Song_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_MusicRecording" ex WHERE ex.s = t0.s);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Song"(s) SELECT DISTINCT t0.s FROM "dbrdf_Song_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Song_delta_old";
        INSERT INTO "dbrdf_Song_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Song_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Song_delta_new";

        INSERT INTO "dbrdf_MusicRecording"(s) SELECT DISTINCT t0.s FROM "dbrdf_MusicRecording_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_MusicRecording_delta_old";
        INSERT INTO "dbrdf_MusicRecording_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_MusicRecording_delta_new" t0;
        TRUNCATE TABLE "dbrdf_MusicRecording_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1183
    ---- 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 1184
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nationalTeam_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nationalTeam_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_nationalTeam" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nationalTeam_delta_old" ON "dbrdf_nationalTeam_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nationalTeam_delta_old" ON "dbrdf_nationalTeam_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nationalTeam_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_nationalTeam"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_nationalTeam_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_nationalTeam_delta_old";
        INSERT INTO "dbrdf_nationalTeam_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_nationalTeam_delta_new" t0;
        TRUNCATE TABLE "dbrdf_nationalTeam_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1185
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtNWIDE_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtNWIDE_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_winsAtNWIDE" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtNWIDE_delta_old" ON "dbrdf_winsAtNWIDE_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtNWIDE_delta_old" ON "dbrdf_winsAtNWIDE_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtNWIDE_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_winsAtNWIDE"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_winsAtNWIDE_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_winsAtNWIDE_delta_old";
        INSERT INTO "dbrdf_winsAtNWIDE_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_winsAtNWIDE_delta_new" t0;
        TRUNCATE TABLE "dbrdf_winsAtNWIDE_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1186
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_satellitesDeployed_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_satellitesDeployed_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_satellitesDeployed" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_satellitesDeployed_delta_old" ON "dbrdf_satellitesDeployed_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_satellitesDeployed_delta_old" ON "dbrdf_satellitesDeployed_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_satellitesDeployed_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_satellitesDeployed"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_satellitesDeployed_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_satellitesDeployed_delta_old";
        INSERT INTO "dbrdf_satellitesDeployed_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_satellitesDeployed_delta_new" t0;
        TRUNCATE TABLE "dbrdf_satellitesDeployed_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1187
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_fansgroup_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_fansgroup_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_fansgroup" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_fansgroup_delta_old" ON "dbrdf_fansgroup_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_fansgroup_delta_old" ON "dbrdf_fansgroup_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_fansgroup_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_fansgroup"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_fansgroup_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_fansgroup_delta_old";
        INSERT INTO "dbrdf_fansgroup_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_fansgroup_delta_new" t0;
        TRUNCATE TABLE "dbrdf_fansgroup_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1188
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_wins_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_wins_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_wins" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_wins_delta_old" ON "dbrdf_wins_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_wins_delta_old" ON "dbrdf_wins_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_wins_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_wins"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_wins_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_wins_delta_old";
        INSERT INTO "dbrdf_wins_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_wins_delta_new" t0;
        TRUNCATE TABLE "dbrdf_wins_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1189
    ---- 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 1190
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_freeFlightTime0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_freeFlightTime_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_freeFlightTime_delta_old0";
        INSERT INTO "dbrdf_freeFlightTime_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_freeFlightTime_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_freeFlightTime_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1191
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rebuilder_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rebuilder_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_rebuilder" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rebuilder_delta_old" ON "dbrdf_rebuilder_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rebuilder_delta_old" ON "dbrdf_rebuilder_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rebuilder_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_rebuilder"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_rebuilder_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_rebuilder_delta_old";
        INSERT INTO "dbrdf_rebuilder_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_rebuilder_delta_new" t0;
        TRUNCATE TABLE "dbrdf_rebuilder_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1192
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_orderInOffice_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_orderInOffice_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_orderInOffice" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_orderInOffice_delta_old" ON "dbrdf_orderInOffice_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_orderInOffice_delta_old" ON "dbrdf_orderInOffice_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_orderInOffice_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_orderInOffice"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_orderInOffice_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_orderInOffice_delta_old";
        INSERT INTO "dbrdf_orderInOffice_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_orderInOffice_delta_new" t0;
        TRUNCATE TABLE "dbrdf_orderInOffice_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1193
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_CurlingLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_CurlingLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_CurlingLeague_delta_old";
        INSERT INTO "dbrdf_CurlingLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_CurlingLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_CurlingLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1194
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_GolfLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_GolfLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_GolfLeague_delta_old";
        INSERT INTO "dbrdf_GolfLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_GolfLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_GolfLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1195
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_inclination_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_inclination_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_inclination" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_inclination_delta_old" ON "dbrdf_inclination_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_inclination_delta_old" ON "dbrdf_inclination_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_inclination_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_inclination"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_inclination_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_inclination_delta_old";
        INSERT INTO "dbrdf_inclination_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_inclination_delta_new" t0;
        TRUNCATE TABLE "dbrdf_inclination_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1196
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_populationUrbanDensity0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_populationUrbanDensity_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_populationUrbanDensity_delta_old0";
        INSERT INTO "dbrdf_populationUrbanDensity_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_populationUrbanDensity_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_populationUrbanDensity_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1197
    ---- DEPENDS ON: 853, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/NationalCollegiateAthleticAssociationAthlete>(?X) :- <http://dbpedia.org/ontology/formerHighschool>(?X,?X1) .
    INSERT INTO "dbrdf_NationalCollegiateAthleticAssociationAthlete"(s) SELECT DISTINCT t0.s FROM "dbrdf_formerHighschool" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_NationalCollegiateAthleticAssociationAthlete" 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_NationalCollegiateAthleticAssociationAthlete_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_NationalCollegiateAthleticAssociationAthlete_delta_old"(s) SELECT t0.s FROM "dbrdf_NationalCollegiateAthleticAssociationAthlete" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_NationalCollegiateAthleticAssociationAthlete_delta_old" ON "dbrdf_NationalCollegiateAthleticAssociationAthlete_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_NationalCollegiateAthleticAssociationAthlete_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/NationalCollegiateAthleticAssociationAthlete$delta_new>(?Y) :- <http://dbpedia.org/ontology/NationalCollegiateAthleticAssociationAthlete$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_NationalCollegiateAthleticAssociationAthlete_delta_new"(s) SELECT t1.o FROM "dbrdf_NationalCollegiateAthleticAssociationAthlete_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_NationalCollegiateAthleticAssociationAthlete" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_NationalCollegiateAthleticAssociationAthlete"(s) SELECT DISTINCT t0.s FROM "dbrdf_NationalCollegiateAthleticAssociationAthlete_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_NationalCollegiateAthleticAssociationAthlete_delta_old";
        INSERT INTO "dbrdf_NationalCollegiateAthleticAssociationAthlete_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_NationalCollegiateAthleticAssociationAthlete_delta_new" t0;
        TRUNCATE TABLE "dbrdf_NationalCollegiateAthleticAssociationAthlete_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1198
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfClassrooms_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfClassrooms_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfClassrooms" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfClassrooms_delta_old" ON "dbrdf_numberOfClassrooms_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfClassrooms_delta_old" ON "dbrdf_numberOfClassrooms_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfClassrooms_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_numberOfClassrooms"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfClassrooms_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_numberOfClassrooms_delta_old";
        INSERT INTO "dbrdf_numberOfClassrooms_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfClassrooms_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfClassrooms_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1199
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_finalFlight_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_finalFlight_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_finalFlight" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_finalFlight_delta_old" ON "dbrdf_finalFlight_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_finalFlight_delta_old" ON "dbrdf_finalFlight_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_finalFlight_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_finalFlight"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_finalFlight_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_finalFlight_delta_old";
        INSERT INTO "dbrdf_finalFlight_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_finalFlight_delta_new" t0;
        TRUNCATE TABLE "dbrdf_finalFlight_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1200
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfEntrances_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfEntrances_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfEntrances" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfEntrances_delta_old" ON "dbrdf_numberOfEntrances_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfEntrances_delta_old" ON "dbrdf_numberOfEntrances_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfEntrances_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_numberOfEntrances"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfEntrances_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_numberOfEntrances_delta_old";
        INSERT INTO "dbrdf_numberOfEntrances_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfEntrances_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfEntrances_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1201
    ---- DEPENDS ON: 1200, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Cave>(?X) :- <http://dbpedia.org/ontology/numberOfEntrances>(?X,?X1) .
    INSERT INTO "dbrdf_Cave"(s) SELECT DISTINCT t0.s FROM "dbrdf_numberOfEntrances" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Cave" 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_Cave_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Cave_delta_old"(s) SELECT t0.s FROM "dbrdf_Cave" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Cave_delta_old" ON "dbrdf_Cave_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Cave_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/Cave$delta_new>(?Y) :- <http://dbpedia.org/ontology/Cave$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Cave_delta_new"(s) SELECT t1.o FROM "dbrdf_Cave_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Cave" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Cave"(s) SELECT DISTINCT t0.s FROM "dbrdf_Cave_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Cave_delta_old";
        INSERT INTO "dbrdf_Cave_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Cave_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Cave_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1202
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_facilityId_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_facilityId_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_facilityId" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_facilityId_delta_old" ON "dbrdf_facilityId_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_facilityId_delta_old" ON "dbrdf_facilityId_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_facilityId_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_facilityId"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_facilityId_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_facilityId_delta_old";
        INSERT INTO "dbrdf_facilityId_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_facilityId_delta_new" t0;
        TRUNCATE TABLE "dbrdf_facilityId_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1203
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sisterNewspaper_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sisterNewspaper_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_sisterNewspaper" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sisterNewspaper_delta_old" ON "dbrdf_sisterNewspaper_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sisterNewspaper_delta_old" ON "dbrdf_sisterNewspaper_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sisterNewspaper_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_sisterNewspaper"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_sisterNewspaper_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_sisterNewspaper_delta_old";
        INSERT INTO "dbrdf_sisterNewspaper_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_sisterNewspaper_delta_new" t0;
        TRUNCATE TABLE "dbrdf_sisterNewspaper_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1204
    ---- DEPENDS ON: 545, 243, 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 1205
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceConfluencePlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sourceConfluencePlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_sourceConfluencePlace" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sourceConfluencePlace_delta_old" ON "dbrdf_sourceConfluencePlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sourceConfluencePlace_delta_old" ON "dbrdf_sourceConfluencePlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceConfluencePlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_sourceConfluencePlace"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_sourceConfluencePlace_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_sourceConfluencePlace_delta_old";
        INSERT INTO "dbrdf_sourceConfluencePlace_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_sourceConfluencePlace_delta_new" t0;
        TRUNCATE TABLE "dbrdf_sourceConfluencePlace_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1206
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_depth_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_depth_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_depth" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_depth_delta_old" ON "dbrdf_depth_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_depth_delta_old" ON "dbrdf_depth_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_depth_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_depth"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_depth_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_depth_delta_old";
        INSERT INTO "dbrdf_depth_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_depth_delta_new" t0;
        TRUNCATE TABLE "dbrdf_depth_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1207
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_airportUsing_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_airportUsing_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_airportUsing" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_airportUsing_delta_old" ON "dbrdf_airportUsing_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_airportUsing_delta_old" ON "dbrdf_airportUsing_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_airportUsing_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_airportUsing"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_airportUsing_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_airportUsing_delta_old";
        INSERT INTO "dbrdf_airportUsing_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_airportUsing_delta_new" t0;
        TRUNCATE TABLE "dbrdf_airportUsing_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1208
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_runtime0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_runtime_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_runtime_delta_old0";
        INSERT INTO "dbrdf_runtime_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_runtime_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_runtime_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1209
    ---- 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 1210
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_isPartOfWineRegion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_isPartOfWineRegion_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_isPartOfWineRegion" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_isPartOfWineRegion_delta_old" ON "dbrdf_isPartOfWineRegion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_isPartOfWineRegion_delta_old" ON "dbrdf_isPartOfWineRegion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_isPartOfWineRegion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_isPartOfWineRegion"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_isPartOfWineRegion_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_isPartOfWineRegion_delta_old";
        INSERT INTO "dbrdf_isPartOfWineRegion_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_isPartOfWineRegion_delta_new" t0;
        TRUNCATE TABLE "dbrdf_isPartOfWineRegion_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1211
    ---- 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 1212
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_giniCoefficient_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_giniCoefficient_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_giniCoefficient" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_giniCoefficient_delta_old" ON "dbrdf_giniCoefficient_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_giniCoefficient_delta_old" ON "dbrdf_giniCoefficient_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_giniCoefficient_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_giniCoefficient"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_giniCoefficient_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_giniCoefficient_delta_old";
        INSERT INTO "dbrdf_giniCoefficient_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_giniCoefficient_delta_new" t0;
        TRUNCATE TABLE "dbrdf_giniCoefficient_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1213
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_combatant_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_combatant_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_combatant" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_combatant_delta_old" ON "dbrdf_combatant_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_combatant_delta_old" ON "dbrdf_combatant_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_combatant_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_combatant"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_combatant_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_combatant_delta_old";
        INSERT INTO "dbrdf_combatant_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_combatant_delta_new" t0;
        TRUNCATE TABLE "dbrdf_combatant_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1214
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_governorGeneral_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_governorGeneral_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_governorGeneral" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_governorGeneral_delta_old" ON "dbrdf_governorGeneral_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_governorGeneral_delta_old" ON "dbrdf_governorGeneral_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_governorGeneral_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_governorGeneral"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_governorGeneral_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_governorGeneral_delta_old";
        INSERT INTO "dbrdf_governorGeneral_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_governorGeneral_delta_new" t0;
        TRUNCATE TABLE "dbrdf_governorGeneral_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1215
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Journalist"(s) SELECT DISTINCT t0.s FROM "dbrdf_Journalist_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Journalist_delta_old";
        INSERT INTO "dbrdf_Journalist_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Journalist_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Journalist_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1216
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_majorityLeader_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_majorityLeader_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_majorityLeader" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_majorityLeader_delta_old" ON "dbrdf_majorityLeader_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_majorityLeader_delta_old" ON "dbrdf_majorityLeader_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_majorityLeader_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_majorityLeader"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_majorityLeader_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_majorityLeader_delta_old";
        INSERT INTO "dbrdf_majorityLeader_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_majorityLeader_delta_new" t0;
        TRUNCATE TABLE "dbrdf_majorityLeader_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1217
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lowestState_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lowestState_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lowestState" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lowestState_delta_old" ON "dbrdf_lowestState_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lowestState_delta_old" ON "dbrdf_lowestState_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lowestState_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_lowestState"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lowestState_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_lowestState_delta_old";
        INSERT INTO "dbrdf_lowestState_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lowestState_delta_new" t0;
        TRUNCATE TABLE "dbrdf_lowestState_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1218
    ---- 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 1219
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_circuitName_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_circuitName_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_circuitName" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_circuitName_delta_old" ON "dbrdf_circuitName_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_circuitName_delta_old" ON "dbrdf_circuitName_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_circuitName_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_circuitName"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_circuitName_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_circuitName_delta_old";
        INSERT INTO "dbrdf_circuitName_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_circuitName_delta_new" t0;
        TRUNCATE TABLE "dbrdf_circuitName_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1220
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_associatedRocket_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_associatedRocket_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_associatedRocket" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_associatedRocket_delta_old" ON "dbrdf_associatedRocket_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_associatedRocket_delta_old" ON "dbrdf_associatedRocket_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_associatedRocket_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_associatedRocket"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_associatedRocket_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_associatedRocket_delta_old";
        INSERT INTO "dbrdf_associatedRocket_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_associatedRocket_delta_new" t0;
        TRUNCATE TABLE "dbrdf_associatedRocket_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1221
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ascentDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ascentDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_ascentDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ascentDate_delta_old" ON "dbrdf_ascentDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ascentDate_delta_old" ON "dbrdf_ascentDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ascentDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_ascentDate"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_ascentDate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_ascentDate_delta_old";
        INSERT INTO "dbrdf_ascentDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_ascentDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ascentDate_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1222
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_averageClassSize_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_averageClassSize_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_averageClassSize" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_averageClassSize_delta_old" ON "dbrdf_averageClassSize_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_averageClassSize_delta_old" ON "dbrdf_averageClassSize_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_averageClassSize_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_averageClassSize"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_averageClassSize_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_averageClassSize_delta_old";
        INSERT INTO "dbrdf_averageClassSize_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_averageClassSize_delta_new" t0;
        TRUNCATE TABLE "dbrdf_averageClassSize_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1223
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_command_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_command_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_command" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_command_delta_old" ON "dbrdf_command_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_command_delta_old" ON "dbrdf_command_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_command_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_command"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_command_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_command_delta_old";
        INSERT INTO "dbrdf_command_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_command_delta_new" t0;
        TRUNCATE TABLE "dbrdf_command_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1224
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_fuelSystem_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_fuelSystem_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_fuelSystem" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_fuelSystem_delta_old" ON "dbrdf_fuelSystem_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_fuelSystem_delta_old" ON "dbrdf_fuelSystem_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_fuelSystem_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_fuelSystem"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_fuelSystem_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_fuelSystem_delta_old";
        INSERT INTO "dbrdf_fuelSystem_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_fuelSystem_delta_new" t0;
        TRUNCATE TABLE "dbrdf_fuelSystem_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1225
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_reopened_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_reopened_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_reopened" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_reopened_delta_old" ON "dbrdf_reopened_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_reopened_delta_old" ON "dbrdf_reopened_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_reopened_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_reopened"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_reopened_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_reopened_delta_old";
        INSERT INTO "dbrdf_reopened_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_reopened_delta_new" t0;
        TRUNCATE TABLE "dbrdf_reopened_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1226
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_maximumTemperature0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_maximumTemperature_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_maximumTemperature_delta_old0";
        INSERT INTO "dbrdf_maximumTemperature_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_maximumTemperature_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_maximumTemperature_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1227
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_games_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_games_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_games" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_games_delta_old" ON "dbrdf_games_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_games_delta_old" ON "dbrdf_games_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_games_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_games"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_games_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_games_delta_old";
        INSERT INTO "dbrdf_games_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_games_delta_new" t0;
        TRUNCATE TABLE "dbrdf_games_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1228
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_isPartOfRoute_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_isPartOfRoute_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_isPartOfRoute" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_isPartOfRoute_delta_old" ON "dbrdf_isPartOfRoute_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_isPartOfRoute_delta_old" ON "dbrdf_isPartOfRoute_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_isPartOfRoute_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_isPartOfRoute"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_isPartOfRoute_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_isPartOfRoute_delta_old";
        INSERT INTO "dbrdf_isPartOfRoute_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_isPartOfRoute_delta_new" t0;
        TRUNCATE TABLE "dbrdf_isPartOfRoute_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1229
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_launch_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_launch_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_launch" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_launch_delta_old" ON "dbrdf_launch_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_launch_delta_old" ON "dbrdf_launch_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_launch_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_launch"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_launch_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_launch_delta_old";
        INSERT INTO "dbrdf_launch_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_launch_delta_new" t0;
        TRUNCATE TABLE "dbrdf_launch_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1230
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_island_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_island_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_island" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_island_delta_old" ON "dbrdf_island_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_island_delta_old" ON "dbrdf_island_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_island_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_island"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_island_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_island_delta_old";
        INSERT INTO "dbrdf_island_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_island_delta_new" t0;
        TRUNCATE TABLE "dbrdf_island_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1231
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_boilerPressure_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_boilerPressure_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_boilerPressure" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_boilerPressure_delta_old" ON "dbrdf_boilerPressure_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_boilerPressure_delta_old" ON "dbrdf_boilerPressure_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_boilerPressure_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_boilerPressure"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_boilerPressure_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_boilerPressure_delta_old";
        INSERT INTO "dbrdf_boilerPressure_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_boilerPressure_delta_new" t0;
        TRUNCATE TABLE "dbrdf_boilerPressure_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1232
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_zdb_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_zdb_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_zdb" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_zdb_delta_old" ON "dbrdf_zdb_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_zdb_delta_old" ON "dbrdf_zdb_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_zdb_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_zdb"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_zdb_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_zdb_delta_old";
        INSERT INTO "dbrdf_zdb_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_zdb_delta_new" t0;
        TRUNCATE TABLE "dbrdf_zdb_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1233
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfPages_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfPages_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfPages" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfPages_delta_old" ON "dbrdf_numberOfPages_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfPages_delta_old" ON "dbrdf_numberOfPages_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfPages_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_numberOfPages"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfPages_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_numberOfPages_delta_old";
        INSERT INTO "dbrdf_numberOfPages_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfPages_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfPages_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1234
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_openingYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_openingYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_openingYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_openingYear_delta_old" ON "dbrdf_openingYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_openingYear_delta_old" ON "dbrdf_openingYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_openingYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_openingYear"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_openingYear_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_openingYear_delta_old";
        INSERT INTO "dbrdf_openingYear_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_openingYear_delta_new" t0;
        TRUNCATE TABLE "dbrdf_openingYear_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1235
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_areaUrban0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_areaUrban_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_areaUrban_delta_old0";
        INSERT INTO "dbrdf_areaUrban_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_areaUrban_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_areaUrban_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1236
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_circuitLength_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_circuitLength_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_circuitLength" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_circuitLength_delta_old" ON "dbrdf_circuitLength_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_circuitLength_delta_old" ON "dbrdf_circuitLength_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_circuitLength_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_circuitLength"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_circuitLength_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_circuitLength_delta_old";
        INSERT INTO "dbrdf_circuitLength_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_circuitLength_delta_new" t0;
        TRUNCATE TABLE "dbrdf_circuitLength_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1237
    ---- DEPENDS ON: 1236, 1219, 646, 645, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/FormulaOneRacing>(?X) :- <http://dbpedia.org/ontology/raceLength>(?X,?X1) .
    INSERT INTO "dbrdf_FormulaOneRacing"(s) SELECT DISTINCT t0.s FROM "dbrdf_raceLength" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_FormulaOneRacing" 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_FormulaOneRacing_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_FormulaOneRacing_delta_old"(s) SELECT t0.s FROM "dbrdf_FormulaOneRacing" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_FormulaOneRacing_delta_old" ON "dbrdf_FormulaOneRacing_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_FormulaOneRacing_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/FormulaOneRacing$delta_new>(?Y) :- <http://dbpedia.org/ontology/FormulaOneRacing$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_FormulaOneRacing_delta_new"(s) SELECT t1.o FROM "dbrdf_FormulaOneRacing_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_FormulaOneRacing" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_FormulaOneRacing"(s) SELECT DISTINCT t0.s FROM "dbrdf_FormulaOneRacing_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_FormulaOneRacing_delta_old";
        INSERT INTO "dbrdf_FormulaOneRacing_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_FormulaOneRacing_delta_new" t0;
        TRUNCATE TABLE "dbrdf_FormulaOneRacing_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1238
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_suborbitalFlights_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_suborbitalFlights_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_suborbitalFlights" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_suborbitalFlights_delta_old" ON "dbrdf_suborbitalFlights_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_suborbitalFlights_delta_old" ON "dbrdf_suborbitalFlights_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_suborbitalFlights_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_suborbitalFlights"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_suborbitalFlights_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_suborbitalFlights_delta_old";
        INSERT INTO "dbrdf_suborbitalFlights_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_suborbitalFlights_delta_new" t0;
        TRUNCATE TABLE "dbrdf_suborbitalFlights_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1239
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sales_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sales_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_sales" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sales_delta_old" ON "dbrdf_sales_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sales_delta_old" ON "dbrdf_sales_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sales_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_sales"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_sales_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_sales_delta_old";
        INSERT INTO "dbrdf_sales_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_sales_delta_new" t0;
        TRUNCATE TABLE "dbrdf_sales_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1240
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_fastestLap_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_fastestLap_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_fastestLap" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_fastestLap_delta_old" ON "dbrdf_fastestLap_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_fastestLap_delta_old" ON "dbrdf_fastestLap_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_fastestLap_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_fastestLap"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_fastestLap_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_fastestLap_delta_old";
        INSERT INTO "dbrdf_fastestLap_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_fastestLap_delta_new" t0;
        TRUNCATE TABLE "dbrdf_fastestLap_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1241
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_openingTheme_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_openingTheme_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_openingTheme" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_openingTheme_delta_old" ON "dbrdf_openingTheme_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_openingTheme_delta_old" ON "dbrdf_openingTheme_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_openingTheme_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_openingTheme"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_openingTheme_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_openingTheme_delta_old";
        INSERT INTO "dbrdf_openingTheme_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_openingTheme_delta_new" t0;
        TRUNCATE TABLE "dbrdf_openingTheme_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1242
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_otherWins_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_otherWins_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_otherWins" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_otherWins_delta_old" ON "dbrdf_otherWins_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_otherWins_delta_old" ON "dbrdf_otherWins_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_otherWins_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_otherWins"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_otherWins_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_otherWins_delta_old";
        INSERT INTO "dbrdf_otherWins_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_otherWins_delta_new" t0;
        TRUNCATE TABLE "dbrdf_otherWins_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1243
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_screenActorsGuildAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_screenActorsGuildAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_screenActorsGuildAward" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_screenActorsGuildAward_delta_old" ON "dbrdf_screenActorsGuildAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_screenActorsGuildAward_delta_old" ON "dbrdf_screenActorsGuildAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_screenActorsGuildAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_screenActorsGuildAward"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_screenActorsGuildAward_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_screenActorsGuildAward_delta_old";
        INSERT INTO "dbrdf_screenActorsGuildAward_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_screenActorsGuildAward_delta_new" t0;
        TRUNCATE TABLE "dbrdf_screenActorsGuildAward_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1244
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_compressionRatio_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_compressionRatio_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_compressionRatio" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_compressionRatio_delta_old" ON "dbrdf_compressionRatio_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_compressionRatio_delta_old" ON "dbrdf_compressionRatio_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_compressionRatio_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_compressionRatio"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_compressionRatio_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_compressionRatio_delta_old";
        INSERT INTO "dbrdf_compressionRatio_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_compressionRatio_delta_new" t0;
        TRUNCATE TABLE "dbrdf_compressionRatio_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1245
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstAscentYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstAscentYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_firstAscentYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstAscentYear_delta_old" ON "dbrdf_firstAscentYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstAscentYear_delta_old" ON "dbrdf_firstAscentYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstAscentYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_firstAscentYear"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_firstAscentYear_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_firstAscentYear_delta_old";
        INSERT INTO "dbrdf_firstAscentYear_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_firstAscentYear_delta_new" t0;
        TRUNCATE TABLE "dbrdf_firstAscentYear_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1246
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_visitorsPerDay_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_visitorsPerDay_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_visitorsPerDay" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_visitorsPerDay_delta_old" ON "dbrdf_visitorsPerDay_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_visitorsPerDay_delta_old" ON "dbrdf_visitorsPerDay_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_visitorsPerDay_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_visitorsPerDay"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_visitorsPerDay_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_visitorsPerDay_delta_old";
        INSERT INTO "dbrdf_visitorsPerDay_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_visitorsPerDay_delta_new" t0;
        TRUNCATE TABLE "dbrdf_visitorsPerDay_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1247
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_frequentlyUpdated_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_frequentlyUpdated_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_frequentlyUpdated" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_frequentlyUpdated_delta_old" ON "dbrdf_frequentlyUpdated_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_frequentlyUpdated_delta_old" ON "dbrdf_frequentlyUpdated_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_frequentlyUpdated_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_frequentlyUpdated"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_frequentlyUpdated_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_frequentlyUpdated_delta_old";
        INSERT INTO "dbrdf_frequentlyUpdated_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_frequentlyUpdated_delta_new" t0;
        TRUNCATE TABLE "dbrdf_frequentlyUpdated_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1248
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_capitalElevation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_capitalElevation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_capitalElevation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_capitalElevation_delta_old" ON "dbrdf_capitalElevation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_capitalElevation_delta_old" ON "dbrdf_capitalElevation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_capitalElevation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_capitalElevation"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_capitalElevation_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_capitalElevation_delta_old";
        INSERT INTO "dbrdf_capitalElevation_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_capitalElevation_delta_new" t0;
        TRUNCATE TABLE "dbrdf_capitalElevation_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1249
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectCoordinator_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_projectCoordinator_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_projectCoordinator" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_projectCoordinator_delta_old" ON "dbrdf_projectCoordinator_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_projectCoordinator_delta_old" ON "dbrdf_projectCoordinator_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectCoordinator_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_projectCoordinator"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_projectCoordinator_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_projectCoordinator_delta_old";
        INSERT INTO "dbrdf_projectCoordinator_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_projectCoordinator_delta_new" t0;
        TRUNCATE TABLE "dbrdf_projectCoordinator_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1250
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cluster_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cluster_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_cluster" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cluster_delta_old" ON "dbrdf_cluster_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_cluster_delta_old" ON "dbrdf_cluster_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cluster_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_cluster"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cluster_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_cluster_delta_old";
        INSERT INTO "dbrdf_cluster_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cluster_delta_new" t0;
        TRUNCATE TABLE "dbrdf_cluster_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1251
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_polishFilmAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_polishFilmAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_polishFilmAward" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_polishFilmAward_delta_old" ON "dbrdf_polishFilmAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_polishFilmAward_delta_old" ON "dbrdf_polishFilmAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_polishFilmAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_polishFilmAward"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_polishFilmAward_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_polishFilmAward_delta_old";
        INSERT INTO "dbrdf_polishFilmAward_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_polishFilmAward_delta_new" t0;
        TRUNCATE TABLE "dbrdf_polishFilmAward_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1252
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Conifer"(s) SELECT DISTINCT t0.s FROM "dbrdf_Conifer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Conifer_delta_old";
        INSERT INTO "dbrdf_Conifer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Conifer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Conifer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1253
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_poleDriver_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_poleDriver_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_poleDriver" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_poleDriver_delta_old" ON "dbrdf_poleDriver_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_poleDriver_delta_old" ON "dbrdf_poleDriver_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_poleDriver_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_poleDriver"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_poleDriver_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_poleDriver_delta_old";
        INSERT INTO "dbrdf_poleDriver_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_poleDriver_delta_new" t0;
        TRUNCATE TABLE "dbrdf_poleDriver_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1254
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstLaunch_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstLaunch_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_firstLaunch" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstLaunch_delta_old" ON "dbrdf_firstLaunch_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstLaunch_delta_old" ON "dbrdf_firstLaunch_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstLaunch_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_firstLaunch"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_firstLaunch_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_firstLaunch_delta_old";
        INSERT INTO "dbrdf_firstLaunch_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_firstLaunch_delta_new" t0;
        TRUNCATE TABLE "dbrdf_firstLaunch_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1255
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dissolutionDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dissolutionDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_dissolutionDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dissolutionDate_delta_old" ON "dbrdf_dissolutionDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dissolutionDate_delta_old" ON "dbrdf_dissolutionDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dissolutionDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_dissolutionDate"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_dissolutionDate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_dissolutionDate_delta_old";
        INSERT INTO "dbrdf_dissolutionDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_dissolutionDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_dissolutionDate_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1256
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_costumeDesigner_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_costumeDesigner_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_costumeDesigner" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_costumeDesigner_delta_old" ON "dbrdf_costumeDesigner_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_costumeDesigner_delta_old" ON "dbrdf_costumeDesigner_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_costumeDesigner_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_costumeDesigner"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_costumeDesigner_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_costumeDesigner_delta_old";
        INSERT INTO "dbrdf_costumeDesigner_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_costumeDesigner_delta_new" t0;
        TRUNCATE TABLE "dbrdf_costumeDesigner_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1257
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_wheelbase0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_wheelbase_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_wheelbase_delta_old0";
        INSERT INTO "dbrdf_wheelbase_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_wheelbase_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_wheelbase_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1258
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_reportingMark_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_reportingMark_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_reportingMark" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_reportingMark_delta_old" ON "dbrdf_reportingMark_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_reportingMark_delta_old" ON "dbrdf_reportingMark_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_reportingMark_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_reportingMark"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_reportingMark_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_reportingMark_delta_old";
        INSERT INTO "dbrdf_reportingMark_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_reportingMark_delta_new" t0;
        TRUNCATE TABLE "dbrdf_reportingMark_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1259
    ---- DEPENDS ON: 1258, 1173, 606, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

    -- [Rule] <http://dbpedia.org/ontology/PublicTransitSystem>(?X) :- <http://dbpedia.org/ontology/numberOfVehicles>(?X,?X1) .
    INSERT INTO "dbrdf_PublicTransitSystem"(s) SELECT DISTINCT t0.s FROM "dbrdf_numberOfVehicles" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_PublicTransitSystem" 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_PublicTransitSystem_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_PublicTransitSystem_delta_old"(s) SELECT t0.s FROM "dbrdf_PublicTransitSystem" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_PublicTransitSystem_delta_old" ON "dbrdf_PublicTransitSystem_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_PublicTransitSystem_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/PublicTransitSystem$delta_new>(?Y) :- <http://dbpedia.org/ontology/PublicTransitSystem$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_PublicTransitSystem_delta_new"(s) SELECT t1.o FROM "dbrdf_PublicTransitSystem_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_PublicTransitSystem" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_PublicTransitSystem"(s) SELECT DISTINCT t0.s FROM "dbrdf_PublicTransitSystem_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_PublicTransitSystem_delta_old";
        INSERT INTO "dbrdf_PublicTransitSystem_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_PublicTransitSystem_delta_new" t0;
        TRUNCATE TABLE "dbrdf_PublicTransitSystem_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1260
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_locatedInArea_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_locatedInArea_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_locatedInArea" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_locatedInArea_delta_old" ON "dbrdf_locatedInArea_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_locatedInArea_delta_old" ON "dbrdf_locatedInArea_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_locatedInArea_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_locatedInArea"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_locatedInArea_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_locatedInArea_delta_old";
        INSERT INTO "dbrdf_locatedInArea_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_locatedInArea_delta_new" t0;
        TRUNCATE TABLE "dbrdf_locatedInArea_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1261
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_relation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_relation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_relation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_relation_delta_old" ON "dbrdf_relation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_relation_delta_old" ON "dbrdf_relation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_relation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_relation"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_relation_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_relation_delta_old";
        INSERT INTO "dbrdf_relation_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_relation_delta_new" t0;
        TRUNCATE TABLE "dbrdf_relation_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1262
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dressCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dressCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_dressCode" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dressCode_delta_old" ON "dbrdf_dressCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dressCode_delta_old" ON "dbrdf_dressCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dressCode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_dressCode"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_dressCode_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_dressCode_delta_old";
        INSERT INTO "dbrdf_dressCode_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_dressCode_delta_new" t0;
        TRUNCATE TABLE "dbrdf_dressCode_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1263
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_id_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_id_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_id" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_id_delta_old" ON "dbrdf_id_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_id_delta_old" ON "dbrdf_id_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_id_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_id"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_id_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_id_delta_old";
        INSERT INTO "dbrdf_id_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_id_delta_new" t0;
        TRUNCATE TABLE "dbrdf_id_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1264
    ---- DEPENDS ON: 1263, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/WorldHeritageSite>(?X) :- <http://dbpedia.org/ontology/id>(?X,?X1) .
    INSERT INTO "dbrdf_WorldHeritageSite"(s) SELECT DISTINCT t0.s FROM "dbrdf_id" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_WorldHeritageSite" 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_WorldHeritageSite_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_WorldHeritageSite_delta_old"(s) SELECT t0.s FROM "dbrdf_WorldHeritageSite" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_WorldHeritageSite_delta_old" ON "dbrdf_WorldHeritageSite_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_WorldHeritageSite_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/WorldHeritageSite$delta_new>(?Y) :- <http://dbpedia.org/ontology/WorldHeritageSite$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_WorldHeritageSite_delta_new"(s) SELECT t1.o FROM "dbrdf_WorldHeritageSite_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_WorldHeritageSite" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_WorldHeritageSite"(s) SELECT DISTINCT t0.s FROM "dbrdf_WorldHeritageSite_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_WorldHeritageSite_delta_old";
        INSERT INTO "dbrdf_WorldHeritageSite_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_WorldHeritageSite_delta_new" t0;
        TRUNCATE TABLE "dbrdf_WorldHeritageSite_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1265
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_university_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_university_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_university" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_university_delta_old" ON "dbrdf_university_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_university_delta_old" ON "dbrdf_university_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_university_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_university"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_university_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_university_delta_old";
        INSERT INTO "dbrdf_university_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_university_delta_new" t0;
        TRUNCATE TABLE "dbrdf_university_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1266
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_unknownOutcomes_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_unknownOutcomes_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_unknownOutcomes" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_unknownOutcomes_delta_old" ON "dbrdf_unknownOutcomes_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_unknownOutcomes_delta_old" ON "dbrdf_unknownOutcomes_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_unknownOutcomes_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_unknownOutcomes"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_unknownOutcomes_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_unknownOutcomes_delta_old";
        INSERT INTO "dbrdf_unknownOutcomes_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_unknownOutcomes_delta_new" t0;
        TRUNCATE TABLE "dbrdf_unknownOutcomes_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1267
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_lunarSampleMass0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lunarSampleMass_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_lunarSampleMass_delta_old0";
        INSERT INTO "dbrdf_lunarSampleMass_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lunarSampleMass_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_lunarSampleMass_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1268
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfSpeakers_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfSpeakers_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfSpeakers" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfSpeakers_delta_old" ON "dbrdf_numberOfSpeakers_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfSpeakers_delta_old" ON "dbrdf_numberOfSpeakers_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfSpeakers_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_numberOfSpeakers"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfSpeakers_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_numberOfSpeakers_delta_old";
        INSERT INTO "dbrdf_numberOfSpeakers_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfSpeakers_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfSpeakers_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1269
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_englishName_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_englishName_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_englishName" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_englishName_delta_old" ON "dbrdf_englishName_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_englishName_delta_old" ON "dbrdf_englishName_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_englishName_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_englishName"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_englishName_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_englishName_delta_old";
        INSERT INTO "dbrdf_englishName_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_englishName_delta_new" t0;
        TRUNCATE TABLE "dbrdf_englishName_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1270
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_updated_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_updated_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_updated" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_updated_delta_old" ON "dbrdf_updated_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_updated_delta_old" ON "dbrdf_updated_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_updated_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_updated"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_updated_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_updated_delta_old";
        INSERT INTO "dbrdf_updated_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_updated_delta_new" t0;
        TRUNCATE TABLE "dbrdf_updated_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1271
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_chain_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_chain_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_chain" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_chain_delta_old" ON "dbrdf_chain_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_chain_delta_old" ON "dbrdf_chain_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_chain_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_chain"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_chain_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_chain_delta_old";
        INSERT INTO "dbrdf_chain_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_chain_delta_new" t0;
        TRUNCATE TABLE "dbrdf_chain_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1272
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_landingDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_landingDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_landingDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_landingDate_delta_old" ON "dbrdf_landingDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_landingDate_delta_old" ON "dbrdf_landingDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_landingDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_landingDate"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_landingDate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_landingDate_delta_old";
        INSERT INTO "dbrdf_landingDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_landingDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_landingDate_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1273
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_geneLocation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_geneLocation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_geneLocation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_geneLocation_delta_old" ON "dbrdf_geneLocation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_geneLocation_delta_old" ON "dbrdf_geneLocation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_geneLocation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_geneLocation"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_geneLocation_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_geneLocation_delta_old";
        INSERT INTO "dbrdf_geneLocation_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_geneLocation_delta_new" t0;
        TRUNCATE TABLE "dbrdf_geneLocation_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1274
    ---- DEPENDS ON: 1273, 669, 522, 267, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Gene>(?X) :- <http://dbpedia.org/ontology/MouseGene>(?X) .
    INSERT INTO "dbrdf_Gene"(s) SELECT t0.s FROM "dbrdf_MouseGene" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Gene" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/Gene>(?X) :- <http://dbpedia.org/ontology/HumanGene>(?X) .
    INSERT INTO "dbrdf_Gene"(s) SELECT t0.s FROM "dbrdf_HumanGene" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Gene" 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_Gene_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Gene_delta_old"(s) SELECT t0.s FROM "dbrdf_Gene" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Gene_delta_old" ON "dbrdf_Gene_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Gene_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/Gene$delta_new>(?Y) :- <http://dbpedia.org/ontology/Gene$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Gene_delta_new"(s) SELECT t1.o FROM "dbrdf_Gene_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Gene" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Gene"(s) SELECT DISTINCT t0.s FROM "dbrdf_Gene_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Gene_delta_old";
        INSERT INTO "dbrdf_Gene_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Gene_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Gene_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1275
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_neighboringMunicipality_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_neighboringMunicipality_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_neighboringMunicipality" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_neighboringMunicipality_delta_old" ON "dbrdf_neighboringMunicipality_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_neighboringMunicipality_delta_old" ON "dbrdf_neighboringMunicipality_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_neighboringMunicipality_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_neighboringMunicipality"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_neighboringMunicipality_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_neighboringMunicipality_delta_old";
        INSERT INTO "dbrdf_neighboringMunicipality_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_neighboringMunicipality_delta_new" t0;
        TRUNCATE TABLE "dbrdf_neighboringMunicipality_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1276
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ethnicGroup_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ethnicGroup_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_ethnicGroup" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ethnicGroup_delta_old" ON "dbrdf_ethnicGroup_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ethnicGroup_delta_old" ON "dbrdf_ethnicGroup_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ethnicGroup_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_ethnicGroup"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_ethnicGroup_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_ethnicGroup_delta_old";
        INSERT INTO "dbrdf_ethnicGroup_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_ethnicGroup_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ethnicGroup_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1277
    ---- 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/Software/fileSize$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Software/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/Software/fileSize$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/Software/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 1278
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtJLPGA_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtJLPGA_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_winsAtJLPGA" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtJLPGA_delta_old" ON "dbrdf_winsAtJLPGA_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtJLPGA_delta_old" ON "dbrdf_winsAtJLPGA_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtJLPGA_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_winsAtJLPGA"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_winsAtJLPGA_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_winsAtJLPGA_delta_old";
        INSERT INTO "dbrdf_winsAtJLPGA_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_winsAtJLPGA_delta_new" t0;
        TRUNCATE TABLE "dbrdf_winsAtJLPGA_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1279
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_spacecraft_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_spacecraft_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_spacecraft" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_spacecraft_delta_old" ON "dbrdf_spacecraft_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_spacecraft_delta_old" ON "dbrdf_spacecraft_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_spacecraft_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_spacecraft"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_spacecraft_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_spacecraft_delta_old";
        INSERT INTO "dbrdf_spacecraft_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_spacecraft_delta_new" t0;
        TRUNCATE TABLE "dbrdf_spacecraft_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1280
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_constellation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_constellation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_constellation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_constellation_delta_old" ON "dbrdf_constellation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_constellation_delta_old" ON "dbrdf_constellation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_constellation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_constellation"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_constellation_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_constellation_delta_old";
        INSERT INTO "dbrdf_constellation_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_constellation_delta_new" t0;
        TRUNCATE TABLE "dbrdf_constellation_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1281
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_populationMetroDensity0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_populationMetroDensity_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_populationMetroDensity_delta_old0";
        INSERT INTO "dbrdf_populationMetroDensity_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_populationMetroDensity_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_populationMetroDensity_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1282
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_subjectOfPlay_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_subjectOfPlay_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_subjectOfPlay" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_subjectOfPlay_delta_old" ON "dbrdf_subjectOfPlay_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_subjectOfPlay_delta_old" ON "dbrdf_subjectOfPlay_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_subjectOfPlay_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_subjectOfPlay"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_subjectOfPlay_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_subjectOfPlay_delta_old";
        INSERT INTO "dbrdf_subjectOfPlay_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_subjectOfPlay_delta_new" t0;
        TRUNCATE TABLE "dbrdf_subjectOfPlay_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1283
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_setDesigner_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_setDesigner_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_setDesigner" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_setDesigner_delta_old" ON "dbrdf_setDesigner_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_setDesigner_delta_old" ON "dbrdf_setDesigner_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_setDesigner_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_setDesigner"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_setDesigner_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_setDesigner_delta_old";
        INSERT INTO "dbrdf_setDesigner_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_setDesigner_delta_new" t0;
        TRUNCATE TABLE "dbrdf_setDesigner_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1284
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_impactFactorAsOf_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_impactFactorAsOf_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_impactFactorAsOf" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_impactFactorAsOf_delta_old" ON "dbrdf_impactFactorAsOf_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_impactFactorAsOf_delta_old" ON "dbrdf_impactFactorAsOf_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_impactFactorAsOf_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_impactFactorAsOf"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_impactFactorAsOf_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_impactFactorAsOf_delta_old";
        INSERT INTO "dbrdf_impactFactorAsOf_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_impactFactorAsOf_delta_new" t0;
        TRUNCATE TABLE "dbrdf_impactFactorAsOf_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1285
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_administrativeCollectivity_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_administrativeCollectivity_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_administrativeCollectivity" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_administrativeCollectivity_delta_old" ON "dbrdf_administrativeCollectivity_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_administrativeCollectivity_delta_old" ON "dbrdf_administrativeCollectivity_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_administrativeCollectivity_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_administrativeCollectivity"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_administrativeCollectivity_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_administrativeCollectivity_delta_old";
        INSERT INTO "dbrdf_administrativeCollectivity_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_administrativeCollectivity_delta_new" t0;
        TRUNCATE TABLE "dbrdf_administrativeCollectivity_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1286
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Surname"(s) SELECT DISTINCT t0.s FROM "dbrdf_Surname_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Surname_delta_old";
        INSERT INTO "dbrdf_Surname_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Surname_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Surname_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1287
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_family_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_family_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_family" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_family_delta_old" ON "dbrdf_family_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_family_delta_old" ON "dbrdf_family_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_family_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_family"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_family_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_family_delta_old";
        INSERT INTO "dbrdf_family_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_family_delta_new" t0;
        TRUNCATE TABLE "dbrdf_family_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1288
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_maximumBoatBeam0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_maximumBoatBeam_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_maximumBoatBeam_delta_old0";
        INSERT INTO "dbrdf_maximumBoatBeam_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_maximumBoatBeam_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_maximumBoatBeam_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1289
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationUrban_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_populationUrban_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_populationUrban" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_populationUrban_delta_old" ON "dbrdf_populationUrban_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_populationUrban_delta_old" ON "dbrdf_populationUrban_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationUrban_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_populationUrban"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_populationUrban_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_populationUrban_delta_old";
        INSERT INTO "dbrdf_populationUrban_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_populationUrban_delta_new" t0;
        TRUNCATE TABLE "dbrdf_populationUrban_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1290
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaTotalRanking_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_areaTotalRanking_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_areaTotalRanking" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_areaTotalRanking_delta_old" ON "dbrdf_areaTotalRanking_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_areaTotalRanking_delta_old" ON "dbrdf_areaTotalRanking_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaTotalRanking_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_areaTotalRanking"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_areaTotalRanking_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_areaTotalRanking_delta_old";
        INSERT INTO "dbrdf_areaTotalRanking_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_areaTotalRanking_delta_new" t0;
        TRUNCATE TABLE "dbrdf_areaTotalRanking_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1291
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_hubAirport_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_hubAirport_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_hubAirport" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_hubAirport_delta_old" ON "dbrdf_hubAirport_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_hubAirport_delta_old" ON "dbrdf_hubAirport_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_hubAirport_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_hubAirport"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_hubAirport_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_hubAirport_delta_old";
        INSERT INTO "dbrdf_hubAirport_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_hubAirport_delta_new" t0;
        TRUNCATE TABLE "dbrdf_hubAirport_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1292
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_technique_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_technique_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_technique" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_technique_delta_old" ON "dbrdf_technique_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_technique_delta_old" ON "dbrdf_technique_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_technique_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_technique"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_technique_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_technique_delta_old";
        INSERT INTO "dbrdf_technique_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_technique_delta_new" t0;
        TRUNCATE TABLE "dbrdf_technique_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1293
    ---- DEPENDS ON: 1292, 741, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- [Rule] <http://dbpedia.org/ontology/Painting>(?X) :- <http://dbpedia.org/ontology/style>(?X,?X1) .
    INSERT INTO "dbrdf_Painting0"(s) SELECT DISTINCT t0.s FROM "dbrdf_style" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Painting0" 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_Painting_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Painting_delta_old"(s) SELECT t0.s FROM "dbrdf_Painting" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Painting_delta_old" ON "dbrdf_Painting_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Painting_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Painting_delta_old0"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Painting_delta_old0"(s) SELECT t0.s FROM "dbrdf_Painting0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Painting_delta_old0" ON "dbrdf_Painting_delta_old0"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Painting_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/Painting$delta_new>(?X) :- <http://dbpedia.org/ontology/Painting$delta_old>(?X) .
        INSERT INTO "dbrdf_Painting_delta_new"(s) SELECT t0.s FROM "dbrdf_Painting_delta_old0" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Painting" ex WHERE ex.s = t0.s);


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


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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Painting"(s) SELECT DISTINCT t0.s FROM "dbrdf_Painting_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Painting_delta_old";
        INSERT INTO "dbrdf_Painting_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Painting_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Painting_delta_new";

        INSERT INTO "dbrdf_Painting0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Painting_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_Painting_delta_old0";
        INSERT INTO "dbrdf_Painting_delta_old0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Painting_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_Painting_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1294
    ---- DEPENDS ON: 729, 674, 375, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

    -- [Rule] <http://dbpedia.org/ontology/Instrument>(?X1) :- <http://dbpedia.org/ontology/instrument>(?X,?X1) .
    INSERT INTO "dbrdf_Instrument"(s) SELECT DISTINCT t0.o FROM "dbrdf_instrument" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Instrument" 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_Instrument_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Instrument_delta_old"(s) SELECT t0.s FROM "dbrdf_Instrument" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Instrument_delta_old" ON "dbrdf_Instrument_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Instrument_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/Instrument$delta_new>(?Y) :- <http://dbpedia.org/ontology/Instrument$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Instrument_delta_new"(s) SELECT t1.o FROM "dbrdf_Instrument_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Instrument" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Instrument"(s) SELECT DISTINCT t0.s FROM "dbrdf_Instrument_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Instrument_delta_old";
        INSERT INTO "dbrdf_Instrument_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Instrument_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Instrument_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1295
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_temperature1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_temperature_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_temperature_delta_old1";
        INSERT INTO "dbrdf_temperature_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_temperature_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_temperature_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1296
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftInterceptor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftInterceptor_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_aircraftInterceptor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftInterceptor_delta_old" ON "dbrdf_aircraftInterceptor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftInterceptor_delta_old" ON "dbrdf_aircraftInterceptor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftInterceptor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_aircraftInterceptor"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_aircraftInterceptor_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_aircraftInterceptor_delta_old";
        INSERT INTO "dbrdf_aircraftInterceptor_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_aircraftInterceptor_delta_new" t0;
        TRUNCATE TABLE "dbrdf_aircraftInterceptor_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1297
    ---- DEPENDS ON: 929, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/LunarCrater>(?X) :- <http://dbpedia.org/ontology/LunarCrater/diameter>(?X,?X1) .
    INSERT INTO "dbrdf_LunarCrater"(s) SELECT DISTINCT t0.s FROM "dbrdf_diameter2" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_LunarCrater" 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_LunarCrater_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_LunarCrater_delta_old"(s) SELECT t0.s FROM "dbrdf_LunarCrater" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_LunarCrater_delta_old" ON "dbrdf_LunarCrater_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_LunarCrater_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/LunarCrater$delta_new>(?Y) :- <http://dbpedia.org/ontology/LunarCrater$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_LunarCrater_delta_new"(s) SELECT t1.o FROM "dbrdf_LunarCrater_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_LunarCrater" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_LunarCrater"(s) SELECT DISTINCT t0.s FROM "dbrdf_LunarCrater_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_LunarCrater_delta_old";
        INSERT INTO "dbrdf_LunarCrater_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_LunarCrater_delta_new" t0;
        TRUNCATE TABLE "dbrdf_LunarCrater_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1298
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_teamName_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_teamName_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_teamName" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_teamName_delta_old" ON "dbrdf_teamName_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_teamName_delta_old" ON "dbrdf_teamName_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_teamName_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_teamName"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_teamName_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_teamName_delta_old";
        INSERT INTO "dbrdf_teamName_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_teamName_delta_new" t0;
        TRUNCATE TABLE "dbrdf_teamName_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1299
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_block_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_block_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_block" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_block_delta_old" ON "dbrdf_block_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_block_delta_old" ON "dbrdf_block_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_block_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_block"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_block_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_block_delta_old";
        INSERT INTO "dbrdf_block_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_block_delta_new" t0;
        TRUNCATE TABLE "dbrdf_block_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1300
    ---- DEPENDS ON: 1112, 913, 759, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

    -- [Rule] <http://dbpedia.org/ontology/FilmFestival>(?X) :- <http://dbpedia.org/ontology/film>(?X,?X1) .
    INSERT INTO "dbrdf_FilmFestival"(s) SELECT DISTINCT t0.s FROM "dbrdf_film" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_FilmFestival" 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_FilmFestival_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_FilmFestival_delta_old"(s) SELECT t0.s FROM "dbrdf_FilmFestival" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_FilmFestival_delta_old" ON "dbrdf_FilmFestival_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_FilmFestival_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/FilmFestival$delta_new>(?Y) :- <http://dbpedia.org/ontology/FilmFestival$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_FilmFestival_delta_new"(s) SELECT t1.o FROM "dbrdf_FilmFestival_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_FilmFestival" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_FilmFestival"(s) SELECT DISTINCT t0.s FROM "dbrdf_FilmFestival_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_FilmFestival_delta_old";
        INSERT INTO "dbrdf_FilmFestival_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_FilmFestival_delta_new" t0;
        TRUNCATE TABLE "dbrdf_FilmFestival_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1301
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_homeStadium_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_homeStadium_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_homeStadium" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_homeStadium_delta_old" ON "dbrdf_homeStadium_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_homeStadium_delta_old" ON "dbrdf_homeStadium_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_homeStadium_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_homeStadium"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_homeStadium_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_homeStadium_delta_old";
        INSERT INTO "dbrdf_homeStadium_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_homeStadium_delta_new" t0;
        TRUNCATE TABLE "dbrdf_homeStadium_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1302
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftType_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftType_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_aircraftType" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftType_delta_old" ON "dbrdf_aircraftType_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftType_delta_old" ON "dbrdf_aircraftType_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftType_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_aircraftType"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_aircraftType_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_aircraftType_delta_old";
        INSERT INTO "dbrdf_aircraftType_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_aircraftType_delta_new" t0;
        TRUNCATE TABLE "dbrdf_aircraftType_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1303
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_automobileModel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_automobileModel_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_automobileModel" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_automobileModel_delta_old" ON "dbrdf_automobileModel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_automobileModel_delta_old" ON "dbrdf_automobileModel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_automobileModel_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_automobileModel"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_automobileModel_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_automobileModel_delta_old";
        INSERT INTO "dbrdf_automobileModel_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_automobileModel_delta_new" t0;
        TRUNCATE TABLE "dbrdf_automobileModel_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1304
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsMajorSector_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_alpsMajorSector_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_alpsMajorSector" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_alpsMajorSector_delta_old" ON "dbrdf_alpsMajorSector_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_alpsMajorSector_delta_old" ON "dbrdf_alpsMajorSector_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsMajorSector_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_alpsMajorSector"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_alpsMajorSector_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_alpsMajorSector_delta_old";
        INSERT INTO "dbrdf_alpsMajorSector_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_alpsMajorSector_delta_new" t0;
        TRUNCATE TABLE "dbrdf_alpsMajorSector_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1305
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_composer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_composer_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_composer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_composer_delta_old" ON "dbrdf_composer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_composer_delta_old" ON "dbrdf_composer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_composer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_composer"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_composer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_composer_delta_old";
        INSERT INTO "dbrdf_composer_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_composer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_composer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1306
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_minimumElevation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_minimumElevation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_minimumElevation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_minimumElevation_delta_old" ON "dbrdf_minimumElevation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_minimumElevation_delta_old" ON "dbrdf_minimumElevation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_minimumElevation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_minimumElevation"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_minimumElevation_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_minimumElevation_delta_old";
        INSERT INTO "dbrdf_minimumElevation_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_minimumElevation_delta_new" t0;
        TRUNCATE TABLE "dbrdf_minimumElevation_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1307
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_cargoFuel0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cargoFuel_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_cargoFuel_delta_old0";
        INSERT INTO "dbrdf_cargoFuel_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cargoFuel_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_cargoFuel_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1308
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_team_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_team_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_team" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_team_delta_old" ON "dbrdf_team_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_team_delta_old" ON "dbrdf_team_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_team_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_team"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_team_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_team_delta_old";
        INSERT INTO "dbrdf_team_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_team_delta_new" t0;
        TRUNCATE TABLE "dbrdf_team_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1309
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_producer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_producer_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_producer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_producer_delta_old" ON "dbrdf_producer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_producer_delta_old" ON "dbrdf_producer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_producer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_producer"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_producer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_producer_delta_old";
        INSERT INTO "dbrdf_producer_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_producer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_producer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1310
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_destructionDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_destructionDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_destructionDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_destructionDate_delta_old" ON "dbrdf_destructionDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_destructionDate_delta_old" ON "dbrdf_destructionDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_destructionDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_destructionDate"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_destructionDate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_destructionDate_delta_old";
        INSERT INTO "dbrdf_destructionDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_destructionDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_destructionDate_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1311
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsSoiusaCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_alpsSoiusaCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_alpsSoiusaCode" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_alpsSoiusaCode_delta_old" ON "dbrdf_alpsSoiusaCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_alpsSoiusaCode_delta_old" ON "dbrdf_alpsSoiusaCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsSoiusaCode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_alpsSoiusaCode"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_alpsSoiusaCode_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_alpsSoiusaCode_delta_old";
        INSERT INTO "dbrdf_alpsSoiusaCode_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_alpsSoiusaCode_delta_new" t0;
        TRUNCATE TABLE "dbrdf_alpsSoiusaCode_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1312
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_managementElevation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_managementElevation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_managementElevation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_managementElevation_delta_old" ON "dbrdf_managementElevation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_managementElevation_delta_old" ON "dbrdf_managementElevation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_managementElevation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_managementElevation"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_managementElevation_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_managementElevation_delta_old";
        INSERT INTO "dbrdf_managementElevation_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_managementElevation_delta_new" t0;
        TRUNCATE TABLE "dbrdf_managementElevation_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1313
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_seatingCapacity_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_seatingCapacity_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_seatingCapacity" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_seatingCapacity_delta_old" ON "dbrdf_seatingCapacity_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_seatingCapacity_delta_old" ON "dbrdf_seatingCapacity_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_seatingCapacity_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_seatingCapacity"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_seatingCapacity_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_seatingCapacity_delta_old";
        INSERT INTO "dbrdf_seatingCapacity_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_seatingCapacity_delta_new" t0;
        TRUNCATE TABLE "dbrdf_seatingCapacity_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1314
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_floorArea_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_floorArea_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_floorArea" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_floorArea_delta_old" ON "dbrdf_floorArea_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_floorArea_delta_old" ON "dbrdf_floorArea_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_floorArea_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_floorArea"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_floorArea_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_floorArea_delta_old";
        INSERT INTO "dbrdf_floorArea_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_floorArea_delta_new" t0;
        TRUNCATE TABLE "dbrdf_floorArea_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1315
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_musicFusionGenre_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_musicFusionGenre_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_musicFusionGenre" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_musicFusionGenre_delta_old" ON "dbrdf_musicFusionGenre_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_musicFusionGenre_delta_old" ON "dbrdf_musicFusionGenre_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_musicFusionGenre_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_musicFusionGenre"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_musicFusionGenre_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_musicFusionGenre_delta_old";
        INSERT INTO "dbrdf_musicFusionGenre_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_musicFusionGenre_delta_new" t0;
        TRUNCATE TABLE "dbrdf_musicFusionGenre_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1316
    ---- DEPENDS ON: 1315, 792, 501, 101, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [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>(?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/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/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>(?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;

    -- [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;

    -- 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 1317
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_managerClub_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_managerClub_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_managerClub" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_managerClub_delta_old" ON "dbrdf_managerClub_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_managerClub_delta_old" ON "dbrdf_managerClub_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_managerClub_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_managerClub"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_managerClub_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_managerClub_delta_old";
        INSERT INTO "dbrdf_managerClub_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_managerClub_delta_new" t0;
        TRUNCATE TABLE "dbrdf_managerClub_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1318
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_interest_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_interest_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_interest" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_interest_delta_old" ON "dbrdf_interest_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_interest_delta_old" ON "dbrdf_interest_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_interest_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_interest"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_interest_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_interest_delta_old";
        INSERT INTO "dbrdf_interest_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_interest_delta_new" t0;
        TRUNCATE TABLE "dbrdf_interest_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1319
    ---- DEPENDS ON: 1318, 857, 782, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

    -- [Rule] <http://dbpedia.org/ontology/SiteOfSpecialScientificInterest>(?X) :- <http://dbpedia.org/ontology/areaOfSearch>(?X,?X1) .
    INSERT INTO "dbrdf_SiteOfSpecialScientificInterest"(s) SELECT DISTINCT t0.s FROM "dbrdf_areaOfSearch" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_SiteOfSpecialScientificInterest" 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_SiteOfSpecialScientificInterest_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SiteOfSpecialScientificInterest_delta_old"(s) SELECT t0.s FROM "dbrdf_SiteOfSpecialScientificInterest" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SiteOfSpecialScientificInterest_delta_old" ON "dbrdf_SiteOfSpecialScientificInterest_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SiteOfSpecialScientificInterest_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/SiteOfSpecialScientificInterest$delta_new>(?Y) :- <http://dbpedia.org/ontology/SiteOfSpecialScientificInterest$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_SiteOfSpecialScientificInterest_delta_new"(s) SELECT t1.o FROM "dbrdf_SiteOfSpecialScientificInterest_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_SiteOfSpecialScientificInterest" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_SiteOfSpecialScientificInterest"(s) SELECT DISTINCT t0.s FROM "dbrdf_SiteOfSpecialScientificInterest_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SiteOfSpecialScientificInterest_delta_old";
        INSERT INTO "dbrdf_SiteOfSpecialScientificInterest_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SiteOfSpecialScientificInterest_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SiteOfSpecialScientificInterest_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1320
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceState_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sourceState_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_sourceState" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sourceState_delta_old" ON "dbrdf_sourceState_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sourceState_delta_old" ON "dbrdf_sourceState_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceState_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_sourceState"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_sourceState_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_sourceState_delta_old";
        INSERT INTO "dbrdf_sourceState_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_sourceState_delta_new" t0;
        TRUNCATE TABLE "dbrdf_sourceState_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1321
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtSun_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtSun_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_winsAtSun" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtSun_delta_old" ON "dbrdf_winsAtSun_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtSun_delta_old" ON "dbrdf_winsAtSun_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtSun_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_winsAtSun"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_winsAtSun_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_winsAtSun_delta_old";
        INSERT INTO "dbrdf_winsAtSun_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_winsAtSun_delta_new" t0;
        TRUNCATE TABLE "dbrdf_winsAtSun_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1322
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_secondLeader_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_secondLeader_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_secondLeader" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_secondLeader_delta_old" ON "dbrdf_secondLeader_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_secondLeader_delta_old" ON "dbrdf_secondLeader_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_secondLeader_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_secondLeader"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_secondLeader_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_secondLeader_delta_old";
        INSERT INTO "dbrdf_secondLeader_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_secondLeader_delta_new" t0;
        TRUNCATE TABLE "dbrdf_secondLeader_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1323
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_americanComedyAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_americanComedyAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_americanComedyAward" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_americanComedyAward_delta_old" ON "dbrdf_americanComedyAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_americanComedyAward_delta_old" ON "dbrdf_americanComedyAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_americanComedyAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_americanComedyAward"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_americanComedyAward_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_americanComedyAward_delta_old";
        INSERT INTO "dbrdf_americanComedyAward_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_americanComedyAward_delta_new" t0;
        TRUNCATE TABLE "dbrdf_americanComedyAward_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1324
    ---- DEPENDS ON: 1323, 1057, 371, 129, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Comedian>(?X) :- <http://dbpedia.org/ontology/olivierAward>(?X,?X1) .
    INSERT INTO "dbrdf_Comedian"(s) SELECT DISTINCT t0.s FROM "dbrdf_olivierAward" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Comedian" 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_Comedian_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Comedian_delta_old"(s) SELECT t0.s FROM "dbrdf_Comedian" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Comedian_delta_old" ON "dbrdf_Comedian_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Comedian_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/Comedian$delta_new>(?Y) :- <http://dbpedia.org/ontology/Comedian$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Comedian_delta_new"(s) SELECT t1.o FROM "dbrdf_Comedian_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Comedian" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Comedian"(s) SELECT DISTINCT t0.s FROM "dbrdf_Comedian_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Comedian_delta_old";
        INSERT INTO "dbrdf_Comedian_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Comedian_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Comedian_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1325
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceConfluencePosition_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sourceConfluencePosition_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_sourceConfluencePosition" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sourceConfluencePosition_delta_old" ON "dbrdf_sourceConfluencePosition_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sourceConfluencePosition_delta_old" ON "dbrdf_sourceConfluencePosition_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceConfluencePosition_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_sourceConfluencePosition"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_sourceConfluencePosition_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_sourceConfluencePosition_delta_old";
        INSERT INTO "dbrdf_sourceConfluencePosition_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_sourceConfluencePosition_delta_new" t0;
        TRUNCATE TABLE "dbrdf_sourceConfluencePosition_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1326
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerTeam_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_formerTeam_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_formerTeam" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_formerTeam_delta_old" ON "dbrdf_formerTeam_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_formerTeam_delta_old" ON "dbrdf_formerTeam_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerTeam_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_formerTeam"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_formerTeam_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_formerTeam_delta_old";
        INSERT INTO "dbrdf_formerTeam_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_formerTeam_delta_new" t0;
        TRUNCATE TABLE "dbrdf_formerTeam_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1327
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nationality_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nationality_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_nationality" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nationality_delta_old" ON "dbrdf_nationality_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nationality_delta_old" ON "dbrdf_nationality_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nationality_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_nationality"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_nationality_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_nationality_delta_old";
        INSERT INTO "dbrdf_nationality_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_nationality_delta_new" t0;
        TRUNCATE TABLE "dbrdf_nationality_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1328
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_award_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_award_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_award" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_award_delta_old" ON "dbrdf_award_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_award_delta_old" ON "dbrdf_award_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_award_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_award"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_award_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_award_delta_old";
        INSERT INTO "dbrdf_award_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_award_delta_new" t0;
        TRUNCATE TABLE "dbrdf_award_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1329
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_startYearOfInsertion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_startYearOfInsertion_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_startYearOfInsertion" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_startYearOfInsertion_delta_old" ON "dbrdf_startYearOfInsertion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_startYearOfInsertion_delta_old" ON "dbrdf_startYearOfInsertion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_startYearOfInsertion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_startYearOfInsertion"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_startYearOfInsertion_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_startYearOfInsertion_delta_old";
        INSERT INTO "dbrdf_startYearOfInsertion_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_startYearOfInsertion_delta_new" t0;
        TRUNCATE TABLE "dbrdf_startYearOfInsertion_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1330
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_trainerYears_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_trainerYears_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_trainerYears" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_trainerYears_delta_old" ON "dbrdf_trainerYears_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_trainerYears_delta_old" ON "dbrdf_trainerYears_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_trainerYears_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_trainerYears"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_trainerYears_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_trainerYears_delta_old";
        INSERT INTO "dbrdf_trainerYears_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_trainerYears_delta_new" t0;
        TRUNCATE TABLE "dbrdf_trainerYears_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1331
    ---- DEPENDS ON: 918, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/SportsTeamMember>(?X) :- <http://dbpedia.org/ontology/squadNumber>(?X,?X1) .
    INSERT INTO "dbrdf_SportsTeamMember"(s) SELECT DISTINCT t0.s FROM "dbrdf_squadNumber" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_SportsTeamMember" 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_SportsTeamMember_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SportsTeamMember_delta_old"(s) SELECT t0.s FROM "dbrdf_SportsTeamMember" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SportsTeamMember_delta_old" ON "dbrdf_SportsTeamMember_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SportsTeamMember_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/SportsTeamMember$delta_new>(?Y) :- <http://dbpedia.org/ontology/SportsTeamMember$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_SportsTeamMember_delta_new"(s) SELECT t1.o FROM "dbrdf_SportsTeamMember_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_SportsTeamMember" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_SportsTeamMember"(s) SELECT DISTINCT t0.s FROM "dbrdf_SportsTeamMember_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SportsTeamMember_delta_old";
        INSERT INTO "dbrdf_SportsTeamMember_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SportsTeamMember_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SportsTeamMember_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1332
    ---- DEPENDS ON: 1331, 895, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/OrganisationMember>(?X) :- <http://dbpedia.org/ontology/SportsTeamMember>(?X) .
    INSERT INTO "dbrdf_OrganisationMember"(s) SELECT t0.s FROM "dbrdf_SportsTeamMember" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_OrganisationMember" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/OrganisationMember>(?X1) :- <http://dbpedia.org/ontology/organisationMember>(?X,?X1) .
    INSERT INTO "dbrdf_OrganisationMember"(s) SELECT DISTINCT t0.o FROM "dbrdf_organisationMember" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_OrganisationMember" 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_OrganisationMember_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_OrganisationMember_delta_old"(s) SELECT t0.s FROM "dbrdf_OrganisationMember" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_OrganisationMember_delta_old" ON "dbrdf_OrganisationMember_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_OrganisationMember_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/OrganisationMember$delta_new>(?Y) :- <http://dbpedia.org/ontology/OrganisationMember$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_OrganisationMember_delta_new"(s) SELECT t1.o FROM "dbrdf_OrganisationMember_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_OrganisationMember" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_OrganisationMember"(s) SELECT DISTINCT t0.s FROM "dbrdf_OrganisationMember_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_OrganisationMember_delta_old";
        INSERT INTO "dbrdf_OrganisationMember_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_OrganisationMember_delta_new" t0;
        TRUNCATE TABLE "dbrdf_OrganisationMember_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1333
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_routeEndDirection_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_routeEndDirection_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_routeEndDirection" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_routeEndDirection_delta_old" ON "dbrdf_routeEndDirection_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_routeEndDirection_delta_old" ON "dbrdf_routeEndDirection_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_routeEndDirection_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_routeEndDirection"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_routeEndDirection_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_routeEndDirection_delta_old";
        INSERT INTO "dbrdf_routeEndDirection_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_routeEndDirection_delta_new" t0;
        TRUNCATE TABLE "dbrdf_routeEndDirection_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1334
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_isHandicappedAccessible_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_isHandicappedAccessible_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_isHandicappedAccessible" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_isHandicappedAccessible_delta_old" ON "dbrdf_isHandicappedAccessible_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_isHandicappedAccessible_delta_old" ON "dbrdf_isHandicappedAccessible_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_isHandicappedAccessible_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_isHandicappedAccessible"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_isHandicappedAccessible_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_isHandicappedAccessible_delta_old";
        INSERT INTO "dbrdf_isHandicappedAccessible_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_isHandicappedAccessible_delta_new" t0;
        TRUNCATE TABLE "dbrdf_isHandicappedAccessible_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1335
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cmykCoordinateBlack_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cmykCoordinateBlack_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_cmykCoordinateBlack" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cmykCoordinateBlack_delta_old" ON "dbrdf_cmykCoordinateBlack_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_cmykCoordinateBlack_delta_old" ON "dbrdf_cmykCoordinateBlack_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cmykCoordinateBlack_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_cmykCoordinateBlack"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cmykCoordinateBlack_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_cmykCoordinateBlack_delta_old";
        INSERT INTO "dbrdf_cmykCoordinateBlack_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cmykCoordinateBlack_delta_new" t0;
        TRUNCATE TABLE "dbrdf_cmykCoordinateBlack_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1336
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nrhpType_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nrhpType_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_nrhpType" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nrhpType_delta_old" ON "dbrdf_nrhpType_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nrhpType_delta_old" ON "dbrdf_nrhpType_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nrhpType_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_nrhpType"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_nrhpType_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_nrhpType_delta_old";
        INSERT INTO "dbrdf_nrhpType_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_nrhpType_delta_new" t0;
        TRUNCATE TABLE "dbrdf_nrhpType_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1337
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_accessDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_accessDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_accessDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_accessDate_delta_old" ON "dbrdf_accessDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_accessDate_delta_old" ON "dbrdf_accessDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_accessDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/accessDate$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/accessDate$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
