    CREATE LOCAL TEMPORARY TABLE "dbrdf_temperature_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/temperature$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/temperature$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_temperature_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_temperature_delta_old0" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_temperature0" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_temperature0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_temperature_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_temperature_delta_old0";
        INSERT INTO "dbrdf_temperature_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_temperature_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_temperature_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 657
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_league_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_league_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_league" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_league_delta_old" ON "dbrdf_league_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_league_delta_old" ON "dbrdf_league_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_league_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 658
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_choreographer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_choreographer_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_choreographer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_choreographer_delta_old" ON "dbrdf_choreographer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_choreographer_delta_old" ON "dbrdf_choreographer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_choreographer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 659
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_addressInRoad_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_addressInRoad_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_addressInRoad" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_addressInRoad_delta_old" ON "dbrdf_addressInRoad_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_addressInRoad_delta_old" ON "dbrdf_addressInRoad_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_addressInRoad_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 660
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_regionServed_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_regionServed_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_regionServed" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_regionServed_delta_old" ON "dbrdf_regionServed_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_regionServed_delta_old" ON "dbrdf_regionServed_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_regionServed_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 661
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nonFictionSubject_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nonFictionSubject_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_nonFictionSubject" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nonFictionSubject_delta_old" ON "dbrdf_nonFictionSubject_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nonFictionSubject_delta_old" ON "dbrdf_nonFictionSubject_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nonFictionSubject_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 662
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_owner_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_owner_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_owner" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_owner_delta_old" ON "dbrdf_owner_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_owner_delta_old" ON "dbrdf_owner_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_owner_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 663
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_commandStructure_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_commandStructure_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_commandStructure" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_commandStructure_delta_old" ON "dbrdf_commandStructure_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_commandStructure_delta_old" ON "dbrdf_commandStructure_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_commandStructure_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 664
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_totalDiscs_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_totalDiscs_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_totalDiscs" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_totalDiscs_delta_old" ON "dbrdf_totalDiscs_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_totalDiscs_delta_old" ON "dbrdf_totalDiscs_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_totalDiscs_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 665
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_coachingRecord_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_coachingRecord_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_coachingRecord" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_coachingRecord_delta_old" ON "dbrdf_coachingRecord_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_coachingRecord_delta_old" ON "dbrdf_coachingRecord_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_coachingRecord_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 666
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_demographicsAsOf_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_demographicsAsOf_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_demographicsAsOf" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_demographicsAsOf_delta_old" ON "dbrdf_demographicsAsOf_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_demographicsAsOf_delta_old" ON "dbrdf_demographicsAsOf_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_demographicsAsOf_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 667
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_frequencyOfPublication_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_frequencyOfPublication_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_frequencyOfPublication" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_frequencyOfPublication_delta_old" ON "dbrdf_frequencyOfPublication_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_frequencyOfPublication_delta_old" ON "dbrdf_frequencyOfPublication_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_frequencyOfPublication_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 668
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dischargeAverage_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dischargeAverage_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_dischargeAverage0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dischargeAverage_delta_old0" ON "dbrdf_dischargeAverage_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_dischargeAverage_delta_old0" ON "dbrdf_dischargeAverage_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dischargeAverage_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_dischargeAverage0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_dischargeAverage_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_dischargeAverage_delta_old0";
        INSERT INTO "dbrdf_dischargeAverage_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_dischargeAverage_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_dischargeAverage_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 669
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_orthologousGene_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_orthologousGene_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_orthologousGene" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_orthologousGene_delta_old" ON "dbrdf_orthologousGene_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_orthologousGene_delta_old" ON "dbrdf_orthologousGene_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_orthologousGene_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 670
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_deathCause_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_deathCause_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_deathCause" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_deathCause_delta_old" ON "dbrdf_deathCause_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_deathCause_delta_old" ON "dbrdf_deathCause_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_deathCause_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 671
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfStations_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfStations_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfStations" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfStations_delta_old" ON "dbrdf_numberOfStations_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfStations_delta_old" ON "dbrdf_numberOfStations_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfStations_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 672
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfRestaurants_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfRestaurants_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfRestaurants" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfRestaurants_delta_old" ON "dbrdf_numberOfRestaurants_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfRestaurants_delta_old" ON "dbrdf_numberOfRestaurants_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfRestaurants_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 673
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_disbanded_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_disbanded_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_disbanded" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_disbanded_delta_old" ON "dbrdf_disbanded_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_disbanded_delta_old" ON "dbrdf_disbanded_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_disbanded_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 674
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_musicians_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_musicians_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_musicians" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_musicians_delta_old" ON "dbrdf_musicians_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_musicians_delta_old" ON "dbrdf_musicians_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_musicians_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 675
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectKeyword_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_projectKeyword_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_projectKeyword" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_projectKeyword_delta_old" ON "dbrdf_projectKeyword_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_projectKeyword_delta_old" ON "dbrdf_projectKeyword_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectKeyword_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 676
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_residence_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_residence_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_residence" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_residence_delta_old" ON "dbrdf_residence_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_residence_delta_old" ON "dbrdf_residence_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_residence_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 677
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_bandMember_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_bandMember_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_bandMember" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_bandMember_delta_old" ON "dbrdf_bandMember_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_bandMember_delta_old" ON "dbrdf_bandMember_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_bandMember_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 678
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_waistSize_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_waistSize_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_waistSize" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_waistSize_delta_old" ON "dbrdf_waistSize_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_waistSize_delta_old" ON "dbrdf_waistSize_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_waistSize_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 679
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_meetingCity_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_meetingCity_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_meetingCity" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_meetingCity_delta_old" ON "dbrdf_meetingCity_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_meetingCity_delta_old" ON "dbrdf_meetingCity_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_meetingCity_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 680
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtAlpg_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtAlpg_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_winsAtAlpg" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtAlpg_delta_old" ON "dbrdf_winsAtAlpg_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtAlpg_delta_old" ON "dbrdf_winsAtAlpg_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtAlpg_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 681
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_humanDevelopmentIndexAsOf_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_humanDevelopmentIndexAsOf_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_humanDevelopmentIndexAsOf" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_humanDevelopmentIndexAsOf_delta_old" ON "dbrdf_humanDevelopmentIndexAsOf_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_humanDevelopmentIndexAsOf_delta_old" ON "dbrdf_humanDevelopmentIndexAsOf_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_humanDevelopmentIndexAsOf_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 682
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rightTributary_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rightTributary_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_rightTributary" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rightTributary_delta_old" ON "dbrdf_rightTributary_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rightTributary_delta_old" ON "dbrdf_rightTributary_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rightTributary_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 683
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dateConstruction_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dateConstruction_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_dateConstruction" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dateConstruction_delta_old" ON "dbrdf_dateConstruction_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dateConstruction_delta_old" ON "dbrdf_dateConstruction_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dateConstruction_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 684
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_resolution_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_resolution_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_resolution" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_resolution_delta_old" ON "dbrdf_resolution_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_resolution_delta_old" ON "dbrdf_resolution_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_resolution_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 685
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_doctoralStudent_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_doctoralStudent_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_doctoralStudent" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_doctoralStudent_delta_old" ON "dbrdf_doctoralStudent_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_doctoralStudent_delta_old" ON "dbrdf_doctoralStudent_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_doctoralStudent_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 686
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_BullFighter"(s) SELECT DISTINCT t0.s FROM "dbrdf_BullFighter_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_BullFighter_delta_old";
        INSERT INTO "dbrdf_BullFighter_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_BullFighter_delta_new" t0;
        TRUNCATE TABLE "dbrdf_BullFighter_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 687
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_satellite_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_satellite_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_satellite" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_satellite_delta_old" ON "dbrdf_satellite_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_satellite_delta_old" ON "dbrdf_satellite_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_satellite_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 688
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfPeopleAttending_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfPeopleAttending_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfPeopleAttending" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfPeopleAttending_delta_old" ON "dbrdf_numberOfPeopleAttending_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfPeopleAttending_delta_old" ON "dbrdf_numberOfPeopleAttending_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfPeopleAttending_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 689
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtPGA_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtPGA_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_winsAtPGA" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtPGA_delta_old" ON "dbrdf_winsAtPGA_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtPGA_delta_old" ON "dbrdf_winsAtPGA_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtPGA_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 690
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_thirdDriver_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_thirdDriver_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_thirdDriver" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_thirdDriver_delta_old" ON "dbrdf_thirdDriver_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_thirdDriver_delta_old" ON "dbrdf_thirdDriver_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_thirdDriver_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 691
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_digitalChannel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_digitalChannel_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_digitalChannel" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_digitalChannel_delta_old" ON "dbrdf_digitalChannel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_digitalChannel_delta_old" ON "dbrdf_digitalChannel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_digitalChannel_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 692
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_highschool_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_highschool_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_highschool" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_highschool_delta_old" ON "dbrdf_highschool_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_highschool_delta_old" ON "dbrdf_highschool_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_highschool_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 693
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_endPoint_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_endPoint_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_endPoint" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_endPoint_delta_old" ON "dbrdf_endPoint_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_endPoint_delta_old" ON "dbrdf_endPoint_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_endPoint_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 694
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_part_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_part_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_part" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_part_delta_old" ON "dbrdf_part_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_part_delta_old" ON "dbrdf_part_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_part_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 695
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_PrimeMinister"(s) SELECT DISTINCT t0.s FROM "dbrdf_PrimeMinister_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_PrimeMinister_delta_old";
        INSERT INTO "dbrdf_PrimeMinister_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_PrimeMinister_delta_new" t0;
        TRUNCATE TABLE "dbrdf_PrimeMinister_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 696
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumDischarge_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_maximumDischarge_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_maximumDischarge" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_maximumDischarge_delta_old" ON "dbrdf_maximumDischarge_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_maximumDischarge_delta_old" ON "dbrdf_maximumDischarge_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumDischarge_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 697
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_periapsis1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_periapsis_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_periapsis_delta_old1";
        INSERT INTO "dbrdf_periapsis_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_periapsis_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_periapsis_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 698
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfVisitors_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfVisitors_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfVisitors" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfVisitors_delta_old" ON "dbrdf_numberOfVisitors_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfVisitors_delta_old" ON "dbrdf_numberOfVisitors_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfVisitors_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 699
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 700
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_originalStartPoint_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_originalStartPoint_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_originalStartPoint" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_originalStartPoint_delta_old" ON "dbrdf_originalStartPoint_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_originalStartPoint_delta_old" ON "dbrdf_originalStartPoint_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_originalStartPoint_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 701
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_playerInTeam_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_playerInTeam_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_playerInTeam" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_playerInTeam_delta_old" ON "dbrdf_playerInTeam_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_playerInTeam_delta_old" ON "dbrdf_playerInTeam_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_playerInTeam_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 702
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_riverBranch_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_riverBranch_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_riverBranch" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_riverBranch_delta_old" ON "dbrdf_riverBranch_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_riverBranch_delta_old" ON "dbrdf_riverBranch_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_riverBranch_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 703
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_spacewalkEnd_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_spacewalkEnd_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_spacewalkEnd" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_spacewalkEnd_delta_old" ON "dbrdf_spacewalkEnd_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_spacewalkEnd_delta_old" ON "dbrdf_spacewalkEnd_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_spacewalkEnd_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 704
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_highestMountain_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_highestMountain_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_highestMountain" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_highestMountain_delta_old" ON "dbrdf_highestMountain_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_highestMountain_delta_old" ON "dbrdf_highestMountain_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_highestMountain_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 705
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_port2UndockingDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_port2UndockingDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_port2UndockingDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_port2UndockingDate_delta_old" ON "dbrdf_port2UndockingDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_port2UndockingDate_delta_old" ON "dbrdf_port2UndockingDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_port2UndockingDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 706
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_bedCount_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_bedCount_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_bedCount" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_bedCount_delta_old" ON "dbrdf_bedCount_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_bedCount_delta_old" ON "dbrdf_bedCount_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_bedCount_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 707
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_worstDefeat_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_worstDefeat_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_worstDefeat" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_worstDefeat_delta_old" ON "dbrdf_worstDefeat_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_worstDefeat_delta_old" ON "dbrdf_worstDefeat_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_worstDefeat_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 708
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_isil_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_isil_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_isil" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_isil_delta_old" ON "dbrdf_isil_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_isil_delta_old" ON "dbrdf_isil_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_isil_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 709
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_whaDraftYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_whaDraftYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_whaDraftYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_whaDraftYear_delta_old" ON "dbrdf_whaDraftYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_whaDraftYear_delta_old" ON "dbrdf_whaDraftYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_whaDraftYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 710
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rocket_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rocket_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_rocket" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rocket_delta_old" ON "dbrdf_rocket_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rocket_delta_old" ON "dbrdf_rocket_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rocket_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 711
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_averageSpeed0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_averageSpeed_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_averageSpeed_delta_old0";
        INSERT INTO "dbrdf_averageSpeed_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_averageSpeed_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_averageSpeed_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 712
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_discontinued_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_discontinued_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_discontinued" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_discontinued_delta_old" ON "dbrdf_discontinued_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_discontinued_delta_old" ON "dbrdf_discontinued_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_discontinued_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 713
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_SoftballLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_SoftballLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SoftballLeague_delta_old";
        INSERT INTO "dbrdf_SoftballLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SoftballLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SoftballLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 714
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_border_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_border_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_border" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_border_delta_old" ON "dbrdf_border_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_border_delta_old" ON "dbrdf_border_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_border_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 715
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_diameter1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_diameter_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_diameter_delta_old1";
        INSERT INTO "dbrdf_diameter_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_diameter_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_diameter_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 716
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mascot_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mascot_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_mascot" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mascot_delta_old" ON "dbrdf_mascot_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mascot_delta_old" ON "dbrdf_mascot_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mascot_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 717
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_managingEditor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_managingEditor_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_managingEditor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_managingEditor_delta_old" ON "dbrdf_managingEditor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_managingEditor_delta_old" ON "dbrdf_managingEditor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_managingEditor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 718
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_failedLaunches_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_failedLaunches_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_failedLaunches" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_failedLaunches_delta_old" ON "dbrdf_failedLaunches_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_failedLaunches_delta_old" ON "dbrdf_failedLaunches_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_failedLaunches_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 719
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_distanceToDouglas_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_distanceToDouglas_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_distanceToDouglas" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_distanceToDouglas_delta_old" ON "dbrdf_distanceToDouglas_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_distanceToDouglas_delta_old" ON "dbrdf_distanceToDouglas_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_distanceToDouglas_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 720
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfParticipatingNations_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfParticipatingNations_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfParticipatingNations" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfParticipatingNations_delta_old" ON "dbrdf_numberOfParticipatingNations_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfParticipatingNations_delta_old" ON "dbrdf_numberOfParticipatingNations_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfParticipatingNations_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 721
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerCallsign_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_formerCallsign_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_formerCallsign" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_formerCallsign_delta_old" ON "dbrdf_formerCallsign_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_formerCallsign_delta_old" ON "dbrdf_formerCallsign_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerCallsign_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 722
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cpu_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cpu_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_cpu" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cpu_delta_old" ON "dbrdf_cpu_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_cpu_delta_old" ON "dbrdf_cpu_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cpu_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 723
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_classis_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_classis_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_classis" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_classis_delta_old" ON "dbrdf_classis_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_classis_delta_old" ON "dbrdf_classis_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_classis_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 724
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationMetroDensity_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_populationMetroDensity_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_populationMetroDensity" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_populationMetroDensity_delta_old" ON "dbrdf_populationMetroDensity_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_populationMetroDensity_delta_old" ON "dbrdf_populationMetroDensity_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationMetroDensity_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 725
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_uRN_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_uRN_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_uRN" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_uRN_delta_old" ON "dbrdf_uRN_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_uRN_delta_old" ON "dbrdf_uRN_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_uRN_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 726
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_totalMass0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_totalMass_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_totalMass_delta_old0";
        INSERT INTO "dbrdf_totalMass_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_totalMass_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_totalMass_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 727
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_showJudge_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_showJudge_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_showJudge" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_showJudge_delta_old" ON "dbrdf_showJudge_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_showJudge_delta_old" ON "dbrdf_showJudge_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_showJudge_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 728
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_areaMetro0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_areaMetro_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_areaMetro_delta_old0";
        INSERT INTO "dbrdf_areaMetro_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_areaMetro_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_areaMetro_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 729
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_instrument_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_instrument_delta_old"(s, o) SELECT t0.s, t0.o 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, o); CREATE INDEX "IDX_1_dbrdf_instrument_delta_old" ON "dbrdf_instrument_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_instrument_delta_new"(s integer, o 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,?X1) :- <http://dbpedia.org/ontology/instrument$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_instrument_delta_new"(s, o) SELECT t1.o, t0.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 AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_instrument"(s, o) SELECT DISTINCT t0.s, t0.o 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, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_instrument_delta_new" t0;
        TRUNCATE TABLE "dbrdf_instrument_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 730
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_chiefEditor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_chiefEditor_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_chiefEditor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_chiefEditor_delta_old" ON "dbrdf_chiefEditor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_chiefEditor_delta_old" ON "dbrdf_chiefEditor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_chiefEditor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 731
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_faaLocationIdentifier_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_faaLocationIdentifier_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_faaLocationIdentifier" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_faaLocationIdentifier_delta_old" ON "dbrdf_faaLocationIdentifier_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_faaLocationIdentifier_delta_old" ON "dbrdf_faaLocationIdentifier_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_faaLocationIdentifier_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 732
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_billed_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_billed_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_billed" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_billed_delta_old" ON "dbrdf_billed_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_billed_delta_old" ON "dbrdf_billed_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_billed_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 733
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_serviceModule_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_serviceModule_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_serviceModule" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_serviceModule_delta_old" ON "dbrdf_serviceModule_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_serviceModule_delta_old" ON "dbrdf_serviceModule_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_serviceModule_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 734
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_administrator_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_administrator_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_administrator" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_administrator_delta_old" ON "dbrdf_administrator_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_administrator_delta_old" ON "dbrdf_administrator_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_administrator_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 735
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstAscentPerson_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstAscentPerson_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_firstAscentPerson" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstAscentPerson_delta_old" ON "dbrdf_firstAscentPerson_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstAscentPerson_delta_old" ON "dbrdf_firstAscentPerson_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstAscentPerson_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 736
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaUrban_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_areaUrban_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_areaUrban" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_areaUrban_delta_old" ON "dbrdf_areaUrban_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_areaUrban_delta_old" ON "dbrdf_areaUrban_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaUrban_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_areaUrban"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_areaUrban_delta_new" 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_old";
        INSERT INTO "dbrdf_areaUrban_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_areaUrban_delta_new" t0;
        TRUNCATE TABLE "dbrdf_areaUrban_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 737
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_CanadianFootballTeam"(s) SELECT DISTINCT t0.s FROM "dbrdf_CanadianFootballTeam_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_CanadianFootballTeam_delta_old";
        INSERT INTO "dbrdf_CanadianFootballTeam_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_CanadianFootballTeam_delta_new" t0;
        TRUNCATE TABLE "dbrdf_CanadianFootballTeam_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 738
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_escapeVelocity_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_escapeVelocity_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_escapeVelocity" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_escapeVelocity_delta_old" ON "dbrdf_escapeVelocity_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_escapeVelocity_delta_old" ON "dbrdf_escapeVelocity_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_escapeVelocity_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 739
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_BasketballLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_BasketballLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_BasketballLeague_delta_old";
        INSERT INTO "dbrdf_BasketballLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_BasketballLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_BasketballLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 740
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ceremonialCounty_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ceremonialCounty_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_ceremonialCounty" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ceremonialCounty_delta_old" ON "dbrdf_ceremonialCounty_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ceremonialCounty_delta_old" ON "dbrdf_ceremonialCounty_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ceremonialCounty_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 741
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_style_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_style_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_style" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_style_delta_old" ON "dbrdf_style_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_style_delta_old" ON "dbrdf_style_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_style_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 742
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 743
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_isPartOfAnatomicalStructure_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_isPartOfAnatomicalStructure_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_isPartOfAnatomicalStructure" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_isPartOfAnatomicalStructure_delta_old" ON "dbrdf_isPartOfAnatomicalStructure_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_isPartOfAnatomicalStructure_delta_old" ON "dbrdf_isPartOfAnatomicalStructure_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_isPartOfAnatomicalStructure_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 744
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_approximateCalories_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_approximateCalories_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_approximateCalories" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_approximateCalories_delta_old" ON "dbrdf_approximateCalories_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_approximateCalories_delta_old" ON "dbrdf_approximateCalories_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_approximateCalories_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 745
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_poorestCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_poorestCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_poorestCountry" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_poorestCountry_delta_old" ON "dbrdf_poorestCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_poorestCountry_delta_old" ON "dbrdf_poorestCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_poorestCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 746
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_county_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_county_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_county" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_county_delta_old" ON "dbrdf_county_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_county_delta_old" ON "dbrdf_county_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_county_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 747
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_custodian_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_custodian_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_custodian" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_custodian_delta_old" ON "dbrdf_custodian_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_custodian_delta_old" ON "dbrdf_custodian_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_custodian_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 748
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_officialSchoolColour_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_officialSchoolColour_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_officialSchoolColour" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_officialSchoolColour_delta_old" ON "dbrdf_officialSchoolColour_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_officialSchoolColour_delta_old" ON "dbrdf_officialSchoolColour_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_officialSchoolColour_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 749
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftBomber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftBomber_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_aircraftBomber" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftBomber_delta_old" ON "dbrdf_aircraftBomber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftBomber_delta_old" ON "dbrdf_aircraftBomber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftBomber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 750
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectEndDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_projectEndDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_projectEndDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_projectEndDate_delta_old" ON "dbrdf_projectEndDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_projectEndDate_delta_old" ON "dbrdf_projectEndDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectEndDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 751
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfSpans_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfSpans_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfSpans" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfSpans_delta_old" ON "dbrdf_numberOfSpans_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfSpans_delta_old" ON "dbrdf_numberOfSpans_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfSpans_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 752
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sportCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sportCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_sportCountry" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sportCountry_delta_old" ON "dbrdf_sportCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sportCountry_delta_old" ON "dbrdf_sportCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sportCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 753
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lunarSampleMass_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lunarSampleMass_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lunarSampleMass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lunarSampleMass_delta_old" ON "dbrdf_lunarSampleMass_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lunarSampleMass_delta_old" ON "dbrdf_lunarSampleMass_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lunarSampleMass_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_lunarSampleMass"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lunarSampleMass_delta_new" 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_old";
        INSERT INTO "dbrdf_lunarSampleMass_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lunarSampleMass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_lunarSampleMass_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 754
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_fuelCapacity0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_fuelCapacity_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_fuelCapacity_delta_old0";
        INSERT INTO "dbrdf_fuelCapacity_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_fuelCapacity_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_fuelCapacity_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 755
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_associate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_associate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_associate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_associate_delta_old" ON "dbrdf_associate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_associate_delta_old" ON "dbrdf_associate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_associate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 756
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_knownFor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_knownFor_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_knownFor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_knownFor_delta_old" ON "dbrdf_knownFor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_knownFor_delta_old" ON "dbrdf_knownFor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_knownFor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 757
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_shareDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_shareDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_shareDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_shareDate_delta_old" ON "dbrdf_shareDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_shareDate_delta_old" ON "dbrdf_shareDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_shareDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 758
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Park_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Park_delta_old"(s) SELECT t0.s FROM "dbrdf_Park" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Park_delta_old" ON "dbrdf_Park_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Park_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Park_delta_old0"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Park_delta_old0"(s) SELECT t0.s FROM "dbrdf_Park0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Park_delta_old0" ON "dbrdf_Park_delta_old0"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Park_delta_new0"(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/Park$delta_new>(?X) :- <http://schema.org/Park$delta_old>(?X) .
        INSERT INTO "dbrdf_Park_delta_new"(s) SELECT t0.s FROM "dbrdf_Park_delta_old0" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Park" ex WHERE ex.s = t0.s);


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


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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Park"(s) SELECT DISTINCT t0.s FROM "dbrdf_Park_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Park_delta_old";
        INSERT INTO "dbrdf_Park_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Park_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Park_delta_new";

        INSERT INTO "dbrdf_Park0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Park_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_Park_delta_old0";
        INSERT INTO "dbrdf_Park_delta_old0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Park_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_Park_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 759
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_closingFilm_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_closingFilm_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_closingFilm" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_closingFilm_delta_old" ON "dbrdf_closingFilm_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_closingFilm_delta_old" ON "dbrdf_closingFilm_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_closingFilm_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 760
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_atcSupplemental_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_atcSupplemental_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_atcSupplemental" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_atcSupplemental_delta_old" ON "dbrdf_atcSupplemental_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_atcSupplemental_delta_old" ON "dbrdf_atcSupplemental_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_atcSupplemental_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 761
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_iso31661Code_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_iso31661Code_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_iso31661Code" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_iso31661Code_delta_old" ON "dbrdf_iso31661Code_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_iso31661Code_delta_old" ON "dbrdf_iso31661Code_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_iso31661Code_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 762
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_subsidiary_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_subsidiary_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_subsidiary" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_subsidiary_delta_old" ON "dbrdf_subsidiary_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_subsidiary_delta_old" ON "dbrdf_subsidiary_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_subsidiary_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 763
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_careerPoints_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_careerPoints_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_careerPoints" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_careerPoints_delta_old" ON "dbrdf_careerPoints_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_careerPoints_delta_old" ON "dbrdf_careerPoints_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_careerPoints_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 764
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_tuition_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_tuition_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_tuition" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_tuition_delta_old" ON "dbrdf_tuition_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_tuition_delta_old" ON "dbrdf_tuition_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_tuition_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 765
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfGraduateStudents_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfGraduateStudents_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfGraduateStudents" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfGraduateStudents_delta_old" ON "dbrdf_numberOfGraduateStudents_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfGraduateStudents_delta_old" ON "dbrdf_numberOfGraduateStudents_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfGraduateStudents_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 766
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_monarch_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_monarch_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_monarch" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_monarch_delta_old" ON "dbrdf_monarch_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_monarch_delta_old" ON "dbrdf_monarch_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_monarch_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 767
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_schoolPatron_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_schoolPatron_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_schoolPatron" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_schoolPatron_delta_old" ON "dbrdf_schoolPatron_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_schoolPatron_delta_old" ON "dbrdf_schoolPatron_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_schoolPatron_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 768
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_notableStudent_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_notableStudent_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_notableStudent" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_notableStudent_delta_old" ON "dbrdf_notableStudent_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_notableStudent_delta_old" ON "dbrdf_notableStudent_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_notableStudent_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 769
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_occupation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_occupation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_occupation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_occupation_delta_old" ON "dbrdf_occupation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_occupation_delta_old" ON "dbrdf_occupation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_occupation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 770
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_language_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_language_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_language" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_language_delta_old" ON "dbrdf_language_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_language_delta_old" ON "dbrdf_language_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_language_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 771
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_profession_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_profession_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_profession" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_profession_delta_old" ON "dbrdf_profession_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_profession_delta_old" ON "dbrdf_profession_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_profession_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 772
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_voiceType_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_voiceType_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_voiceType" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_voiceType_delta_old" ON "dbrdf_voiceType_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_voiceType_delta_old" ON "dbrdf_voiceType_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_voiceType_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 773
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_highestBreak_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_highestBreak_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_highestBreak" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_highestBreak_delta_old" ON "dbrdf_highestBreak_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_highestBreak_delta_old" ON "dbrdf_highestBreak_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_highestBreak_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 774
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_partyNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_partyNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_partyNumber" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_partyNumber_delta_old" ON "dbrdf_partyNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_partyNumber_delta_old" ON "dbrdf_partyNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_partyNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 775
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_startDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_startDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_startDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_startDate_delta_old" ON "dbrdf_startDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_startDate_delta_old" ON "dbrdf_startDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_startDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 776
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_majorIsland_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_majorIsland_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_majorIsland" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_majorIsland_delta_old" ON "dbrdf_majorIsland_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_majorIsland_delta_old" ON "dbrdf_majorIsland_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_majorIsland_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 777
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Amphibian"(s) SELECT DISTINCT t0.s FROM "dbrdf_Amphibian_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Amphibian_delta_old";
        INSERT INTO "dbrdf_Amphibian_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Amphibian_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Amphibian_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 778
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_engine_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_engine_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_engine" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_engine_delta_old" ON "dbrdf_engine_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_engine_delta_old" ON "dbrdf_engine_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_engine_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 779
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_eruptionYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_eruptionYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_eruptionYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_eruptionYear_delta_old" ON "dbrdf_eruptionYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_eruptionYear_delta_old" ON "dbrdf_eruptionYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_eruptionYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 780
    ---- DEPENDS ON: 779, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Volcano>(?X) :- <http://dbpedia.org/ontology/eruptionYear>(?X,?X1) .
    INSERT INTO "dbrdf_Volcano"(s) SELECT DISTINCT t0.s FROM "dbrdf_eruptionYear" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Volcano" 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_Volcano_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Volcano_delta_old"(s) SELECT t0.s FROM "dbrdf_Volcano" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Volcano_delta_old" ON "dbrdf_Volcano_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Volcano_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/Volcano$delta_new>(?Y) :- <http://dbpedia.org/ontology/Volcano$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Volcano_delta_new"(s) SELECT t1.o FROM "dbrdf_Volcano_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Volcano" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Volcano"(s) SELECT DISTINCT t0.s FROM "dbrdf_Volcano_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Volcano_delta_old";
        INSERT INTO "dbrdf_Volcano_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Volcano_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Volcano_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 781
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_filmFareAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_filmFareAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_filmFareAward" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_filmFareAward_delta_old" ON "dbrdf_filmFareAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_filmFareAward_delta_old" ON "dbrdf_filmFareAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_filmFareAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 782
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaOfSearch_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_areaOfSearch_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_areaOfSearch" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_areaOfSearch_delta_old" ON "dbrdf_areaOfSearch_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_areaOfSearch_delta_old" ON "dbrdf_areaOfSearch_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaOfSearch_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 783
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_administrativeDistrict_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_administrativeDistrict_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_administrativeDistrict" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_administrativeDistrict_delta_old" ON "dbrdf_administrativeDistrict_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_administrativeDistrict_delta_old" ON "dbrdf_administrativeDistrict_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_administrativeDistrict_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 784
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_visitorStatisticsAsOf_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_visitorStatisticsAsOf_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_visitorStatisticsAsOf" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_visitorStatisticsAsOf_delta_old" ON "dbrdf_visitorStatisticsAsOf_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_visitorStatisticsAsOf_delta_old" ON "dbrdf_visitorStatisticsAsOf_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_visitorStatisticsAsOf_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 785
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_SkiArea_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SkiArea_delta_old"(s) SELECT t0.s FROM "dbrdf_SkiArea" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SkiArea_delta_old" ON "dbrdf_SkiArea_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SkiArea_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SkiResort_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SkiResort_delta_old"(s) SELECT t0.s FROM "dbrdf_SkiResort" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SkiResort_delta_old" ON "dbrdf_SkiResort_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SkiResort_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/SkiArea$delta_new>(?X) :- <http://schema.org/SkiResort$delta_old>(?X) .
        INSERT INTO "dbrdf_SkiArea_delta_new"(s) SELECT t0.s FROM "dbrdf_SkiResort_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_SkiArea" ex WHERE ex.s = t0.s);


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


        -- <http://schema.org/SkiResort$delta_new>(?X) :- <http://dbpedia.org/ontology/SkiArea$delta_old>(?X) .
        INSERT INTO "dbrdf_SkiResort_delta_new"(s) SELECT t0.s FROM "dbrdf_SkiArea_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_SkiResort" ex WHERE ex.s = t0.s);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_SkiArea"(s) SELECT DISTINCT t0.s FROM "dbrdf_SkiArea_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SkiArea_delta_old";
        INSERT INTO "dbrdf_SkiArea_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SkiArea_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SkiArea_delta_new";

        INSERT INTO "dbrdf_SkiResort"(s) SELECT DISTINCT t0.s FROM "dbrdf_SkiResort_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SkiResort_delta_old";
        INSERT INTO "dbrdf_SkiResort_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SkiResort_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SkiResort_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 786
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_branchFrom_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_branchFrom_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_branchFrom" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_branchFrom_delta_old" ON "dbrdf_branchFrom_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_branchFrom_delta_old" ON "dbrdf_branchFrom_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_branchFrom_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 787
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cmykCoordinateMagenta_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cmykCoordinateMagenta_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_cmykCoordinateMagenta" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cmykCoordinateMagenta_delta_old" ON "dbrdf_cmykCoordinateMagenta_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_cmykCoordinateMagenta_delta_old" ON "dbrdf_cmykCoordinateMagenta_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cmykCoordinateMagenta_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 788
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_subsequentInfrastructure_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_subsequentInfrastructure_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_subsequentInfrastructure" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_subsequentInfrastructure_delta_old" ON "dbrdf_subsequentInfrastructure_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_subsequentInfrastructure_delta_old" ON "dbrdf_subsequentInfrastructure_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_subsequentInfrastructure_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 789
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_periapsis_delta_old2"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_periapsis_delta_old2"(s, o) SELECT t0.s, t0.o FROM "dbrdf_periapsis2" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_periapsis_delta_old2" ON "dbrdf_periapsis_delta_old2"(s, o); CREATE INDEX "IDX_1_dbrdf_periapsis_delta_old2" ON "dbrdf_periapsis_delta_old2"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_periapsis_delta_new2"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 790
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Lieutenant"(s) SELECT DISTINCT t0.s FROM "dbrdf_Lieutenant_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Lieutenant_delta_old";
        INSERT INTO "dbrdf_Lieutenant_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Lieutenant_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Lieutenant_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 791
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumDepth_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_maximumDepth_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_maximumDepth" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_maximumDepth_delta_old" ON "dbrdf_maximumDepth_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_maximumDepth_delta_old" ON "dbrdf_maximumDepth_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumDepth_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 792
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_derivative_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_derivative_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_derivative" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_derivative_delta_old" ON "dbrdf_derivative_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_derivative_delta_old" ON "dbrdf_derivative_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_derivative_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 793
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mouthRegion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mouthRegion_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_mouthRegion" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mouthRegion_delta_old" ON "dbrdf_mouthRegion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mouthRegion_delta_old" ON "dbrdf_mouthRegion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mouthRegion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 794
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_volume_delta_old2"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_volume_delta_old2"(s, o) SELECT t0.s, t0.o FROM "dbrdf_volume2" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_volume_delta_old2" ON "dbrdf_volume_delta_old2"(s, o); CREATE INDEX "IDX_1_dbrdf_volume_delta_old2" ON "dbrdf_volume_delta_old2"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_volume_delta_new2"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 795
    ---- DEPENDS ON: 708, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Library_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Library_delta_old"(s) SELECT t0.s FROM "dbrdf_Library" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Library_delta_old" ON "dbrdf_Library_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Library_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Library_delta_old0"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Library_delta_old0"(s) SELECT t0.s FROM "dbrdf_Library0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Library_delta_old0" ON "dbrdf_Library_delta_old0"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Library_delta_new0"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Library"(s) SELECT DISTINCT t0.s FROM "dbrdf_Library_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Library_delta_old";
        INSERT INTO "dbrdf_Library_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Library_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Library_delta_new";

        INSERT INTO "dbrdf_Library0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Library_delta_new0" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Library_delta_old0";
        INSERT INTO "dbrdf_Library_delta_old0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Library_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_Library_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 796
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_capitalCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_capitalCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_capitalCountry" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_capitalCountry_delta_old" ON "dbrdf_capitalCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_capitalCountry_delta_old" ON "dbrdf_capitalCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_capitalCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 797
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dryCargo_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dryCargo_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_dryCargo" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dryCargo_delta_old" ON "dbrdf_dryCargo_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dryCargo_delta_old" ON "dbrdf_dryCargo_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dryCargo_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 798
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_port2DockingDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_port2DockingDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_port2DockingDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_port2DockingDate_delta_old" ON "dbrdf_port2DockingDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_port2DockingDate_delta_old" ON "dbrdf_port2DockingDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_port2DockingDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 799
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dateExtended_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dateExtended_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_dateExtended" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dateExtended_delta_old" ON "dbrdf_dateExtended_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dateExtended_delta_old" ON "dbrdf_dateExtended_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dateExtended_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 800
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_usSales_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_usSales_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_usSales" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_usSales_delta_old" ON "dbrdf_usSales_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_usSales_delta_old" ON "dbrdf_usSales_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_usSales_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 801
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceRegion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sourceRegion_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_sourceRegion" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sourceRegion_delta_old" ON "dbrdf_sourceRegion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sourceRegion_delta_old" ON "dbrdf_sourceRegion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceRegion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 802
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_hipSize_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_hipSize_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_hipSize" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_hipSize_delta_old" ON "dbrdf_hipSize_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_hipSize_delta_old" ON "dbrdf_hipSize_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_hipSize_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 803
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_executiveHeadteacher_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_executiveHeadteacher_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_executiveHeadteacher" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_executiveHeadteacher_delta_old" ON "dbrdf_executiveHeadteacher_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_executiveHeadteacher_delta_old" ON "dbrdf_executiveHeadteacher_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_executiveHeadteacher_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 804
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_politicalPartyInLegislature_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_politicalPartyInLegislature_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_politicalPartyInLegislature" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_politicalPartyInLegislature_delta_old" ON "dbrdf_politicalPartyInLegislature_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_politicalPartyInLegislature_delta_old" ON "dbrdf_politicalPartyInLegislature_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_politicalPartyInLegislature_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 805
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_governmentMountain_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_governmentMountain_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_governmentMountain" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_governmentMountain_delta_old" ON "dbrdf_governmentMountain_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_governmentMountain_delta_old" ON "dbrdf_governmentMountain_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_governmentMountain_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 806
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_company_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_company_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_company" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_company_delta_old" ON "dbrdf_company_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_company_delta_old" ON "dbrdf_company_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_company_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 807
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_superintendent_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_superintendent_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_superintendent" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_superintendent_delta_old" ON "dbrdf_superintendent_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_superintendent_delta_old" ON "dbrdf_superintendent_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_superintendent_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 808
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 809
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_serviceStartDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_serviceStartDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_serviceStartDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_serviceStartDate_delta_old" ON "dbrdf_serviceStartDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_serviceStartDate_delta_old" ON "dbrdf_serviceStartDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_serviceStartDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 810
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rightChild_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rightChild_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_rightChild" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rightChild_delta_old" ON "dbrdf_rightChild_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rightChild_delta_old" ON "dbrdf_rightChild_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rightChild_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 811
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastAirDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lastAirDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lastAirDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lastAirDate_delta_old" ON "dbrdf_lastAirDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lastAirDate_delta_old" ON "dbrdf_lastAirDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastAirDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 812
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaLand_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_areaLand_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_areaLand" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_areaLand_delta_old" ON "dbrdf_areaLand_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_areaLand_delta_old" ON "dbrdf_areaLand_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaLand_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 813
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_locationCity_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_locationCity_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_locationCity" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_locationCity_delta_old" ON "dbrdf_locationCity_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_locationCity_delta_old" ON "dbrdf_locationCity_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_locationCity_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 814
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfOrbits_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfOrbits_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfOrbits" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfOrbits_delta_old" ON "dbrdf_numberOfOrbits_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfOrbits_delta_old" ON "dbrdf_numberOfOrbits_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfOrbits_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 815
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_component_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_component_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_component" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_component_delta_old" ON "dbrdf_component_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_component_delta_old" ON "dbrdf_component_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_component_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 816
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_filmPolskiId_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_filmPolskiId_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_filmPolskiId" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_filmPolskiId_delta_old" ON "dbrdf_filmPolskiId_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_filmPolskiId_delta_old" ON "dbrdf_filmPolskiId_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_filmPolskiId_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 817
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_reopeningYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_reopeningYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_reopeningYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_reopeningYear_delta_old" ON "dbrdf_reopeningYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_reopeningYear_delta_old" ON "dbrdf_reopeningYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_reopeningYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 818
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_internationalAffiliation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_internationalAffiliation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_internationalAffiliation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_internationalAffiliation_delta_old" ON "dbrdf_internationalAffiliation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_internationalAffiliation_delta_old" ON "dbrdf_internationalAffiliation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_internationalAffiliation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 819
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastFlightStartDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lastFlightStartDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lastFlightStartDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lastFlightStartDate_delta_old" ON "dbrdf_lastFlightStartDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lastFlightStartDate_delta_old" ON "dbrdf_lastFlightStartDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastFlightStartDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 820
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_silverMedalist_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_silverMedalist_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_silverMedalist" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_silverMedalist_delta_old" ON "dbrdf_silverMedalist_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_silverMedalist_delta_old" ON "dbrdf_silverMedalist_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_silverMedalist_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 821
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_area0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_area_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_area_delta_old0";
        INSERT INTO "dbrdf_area_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_area_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_area_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 822
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_jstor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_jstor_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_jstor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_jstor_delta_old" ON "dbrdf_jstor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_jstor_delta_old" ON "dbrdf_jstor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_jstor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 823
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_carNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_carNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_carNumber" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_carNumber_delta_old" ON "dbrdf_carNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_carNumber_delta_old" ON "dbrdf_carNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_carNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 824
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_runwayLength_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_runwayLength_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_runwayLength" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_runwayLength_delta_old" ON "dbrdf_runwayLength_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_runwayLength_delta_old" ON "dbrdf_runwayLength_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_runwayLength_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 825
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_minimumTemperature0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_minimumTemperature_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_minimumTemperature_delta_old0";
        INSERT INTO "dbrdf_minimumTemperature_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_minimumTemperature_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_minimumTemperature_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 826
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_satScore_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_satScore_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_satScore" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_satScore_delta_old" ON "dbrdf_satScore_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_satScore_delta_old" ON "dbrdf_satScore_delta_old"(o);
