    INSERT INTO "dbrdf_schoolBoard_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27123;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_schoolBoard_delta_old" ON "dbrdf_schoolBoard_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_schoolBoard_delta_old" ON "dbrdf_schoolBoard_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_schoolBoard_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 640
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstFlightEndDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstFlightEndDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27124;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstFlightEndDate_delta_old" ON "dbrdf_firstFlightEndDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstFlightEndDate_delta_old" ON "dbrdf_firstFlightEndDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstFlightEndDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 641
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_stateDelegate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_stateDelegate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27125;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_stateDelegate_delta_old" ON "dbrdf_stateDelegate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_stateDelegate_delta_old" ON "dbrdf_stateDelegate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_stateDelegate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 642
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Referee_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Referee_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27126;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Referee_delta_old" ON "dbrdf_Referee_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Referee_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/Referee$delta_new>(?Y) :- <http://dbpedia.org/ontology/Referee$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Referee_delta_new"(s) SELECT t1.o FROM "dbrdf_Referee_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 27126);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 643
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_president_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_president_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27127;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_president_delta_old" ON "dbrdf_president_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_president_delta_old" ON "dbrdf_president_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_president_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 644
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_originalEndPoint_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_originalEndPoint_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27128;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_originalEndPoint_delta_old" ON "dbrdf_originalEndPoint_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_originalEndPoint_delta_old" ON "dbrdf_originalEndPoint_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_originalEndPoint_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 645
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_raceLength_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_raceLength_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27129;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_raceLength_delta_old" ON "dbrdf_raceLength_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_raceLength_delta_old" ON "dbrdf_raceLength_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_raceLength_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 646
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfLaps_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfLaps_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27130;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfLaps_delta_old" ON "dbrdf_numberOfLaps_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfLaps_delta_old" ON "dbrdf_numberOfLaps_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfLaps_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 647
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rankingsDoubles_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rankingsDoubles_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27131;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rankingsDoubles_delta_old" ON "dbrdf_rankingsDoubles_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rankingsDoubles_delta_old" ON "dbrdf_rankingsDoubles_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rankingsDoubles_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 648
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mainspan_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mainspan_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27132;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mainspan_delta_old" ON "dbrdf_mainspan_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mainspan_delta_old" ON "dbrdf_mainspan_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mainspan_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 649
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_automobilePlatform_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_automobilePlatform_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27133;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_automobilePlatform_delta_old" ON "dbrdf_automobilePlatform_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_automobilePlatform_delta_old" ON "dbrdf_automobilePlatform_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_automobilePlatform_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 650
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_tvComId_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_tvComId_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27134;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_tvComId_delta_old" ON "dbrdf_tvComId_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_tvComId_delta_old" ON "dbrdf_tvComId_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_tvComId_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 651
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_birthName_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_birthName_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27135;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_birthName_delta_old" ON "dbrdf_birthName_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_birthName_delta_old" ON "dbrdf_birthName_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_birthName_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 652
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_port1DockingDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_port1DockingDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27136;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_port1DockingDate_delta_old" ON "dbrdf_port1DockingDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_port1DockingDate_delta_old" ON "dbrdf_port1DockingDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_port1DockingDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 653
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_writer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_writer_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27137;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_writer_delta_old" ON "dbrdf_writer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_writer_delta_old" ON "dbrdf_writer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_writer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 654
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lunarSurfaceTime_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lunarSurfaceTime_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27138;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lunarSurfaceTime_delta_old" ON "dbrdf_lunarSurfaceTime_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lunarSurfaceTime_delta_old" ON "dbrdf_lunarSurfaceTime_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lunarSurfaceTime_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 655
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_drainsTo_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_drainsTo_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27139;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_drainsTo_delta_old" ON "dbrdf_drainsTo_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_drainsTo_delta_old" ON "dbrdf_drainsTo_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_drainsTo_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 656
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_temperature_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_temperature_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27140;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_temperature_delta_old0" ON "dbrdf_temperature_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_temperature_delta_old0" ON "dbrdf_temperature_delta_old0"(o);
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27140 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27140 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27140, 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 "__triples" t0 WHERE t0.p = 27141;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27141 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27141 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27141, 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 "__triples" t0 WHERE t0.p = 27142;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27142 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27142 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27142, 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 "__triples" t0 WHERE t0.p = 27143;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27143 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27143 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27143, 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 "__triples" t0 WHERE t0.p = 27144;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27144 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27144 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27144, 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 "__triples" t0 WHERE t0.p = 27145;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27145 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27145 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27145, 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 "__triples" t0 WHERE t0.p = 27146;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27146 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27146 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27146, 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 "__triples" t0 WHERE t0.p = 27147;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27147 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27147 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27147, 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 "__triples" t0 WHERE t0.p = 27148;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27148 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27148 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27148, 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 "__triples" t0 WHERE t0.p = 27149;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27149 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27149 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27149, 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 "__triples" t0 WHERE t0.p = 27150;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27150 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27150 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27150, 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 "__triples" t0 WHERE t0.p = 27151;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27151 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27151 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27151, 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 "__triples" t0 WHERE t0.p = 27152;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27152 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27152 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27152, 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 "__triples" t0 WHERE t0.p = 27153;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27153 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27153 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27153, 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 "__triples" t0 WHERE t0.p = 27154;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27154 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27154 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27154, 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 "__triples" t0 WHERE t0.p = 27155;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27155 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27155 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27155, 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 "__triples" t0 WHERE t0.p = 27156;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27156 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27156 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27156, 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 "__triples" t0 WHERE t0.p = 27157;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27157 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27157 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27157, 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 "__triples" t0 WHERE t0.p = 27158;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27158 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27158 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27158, 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 "__triples" t0 WHERE t0.p = 27159;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27159 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27159 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27159, 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 "__triples" t0 WHERE t0.p = 27160;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27160 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27160 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27160, 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 "__triples" t0 WHERE t0.p = 27161;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27161 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27161 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27161, 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 "__triples" t0 WHERE t0.p = 27162;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27162 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27162 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27162, 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 "__triples" t0 WHERE t0.p = 27163;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27163 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27163 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27163, 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 "__triples" t0 WHERE t0.p = 27164;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27164 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27164 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27164, 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 "__triples" t0 WHERE t0.p = 27165;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27165 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27165 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27165, 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 "__triples" t0 WHERE t0.p = 27166;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27166 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27166 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27166, 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 "__triples" t0 WHERE t0.p = 27167;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27167 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27167 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27167, 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 "__triples" t0 WHERE t0.p = 27168;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27168 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27168 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27168, 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 "__triples" t0 WHERE t0.p = 27169;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27169 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27169 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27169, 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 27170;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 27170);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27170 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 "__triples" t0 WHERE t0.p = 27171;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27171 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27171 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27171, 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 "__triples" t0 WHERE t0.p = 27172;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27172 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27172 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27172, 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 "__triples" t0 WHERE t0.p = 27173;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27173 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27173 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27173, 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 "__triples" t0 WHERE t0.p = 27174;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27174 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27174 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27174, 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 "__triples" t0 WHERE t0.p = 27175;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27175 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27175 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27175, 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 "__triples" t0 WHERE t0.p = 27176;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27176 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27176 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27176, 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 "__triples" t0 WHERE t0.p = 27177;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27177 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27177 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27177, 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 "__triples" t0 WHERE t0.p = 27178;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27178 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27178 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27178, 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 27179;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 27179);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27179 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 "__triples" t0 WHERE t0.p = 27180;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27180 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27180 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27180, 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 "__triples" t0 WHERE t0.p = 27181;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27181 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27181 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27181, 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 "__triples" t0 WHERE t0.p = 27182;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27182 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27182 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27182, 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 "__triples" t0 WHERE t0.p = 27183;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27183 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27183 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27183, 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 "__triples" t0 WHERE t0.p = 27184;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27184 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27184 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27184, 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 "__triples" t0 WHERE t0.p = 27185;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27185 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27185 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27185, 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 "__triples" t0 WHERE t0.p = 27186;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27186 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27186 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27186, 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 "__triples" t0 WHERE t0.p = 27187;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27187 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27187 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27187, 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 "__triples" t0 WHERE t0.p = 27188;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27188 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27188 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27188, 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 "__triples" t0 WHERE t0.p = 27189;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27189 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27189 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27189, 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 "__triples" t0 WHERE t0.p = 27190;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27190 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27190 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27190, 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 "__triples" t0 WHERE t0.p = 27191;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27191 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27191 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27191, 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 "__triples" t0 WHERE t0.p = 27192;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27192 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27192 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27192, 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 "__triples" t0 WHERE t0.p = 27193;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27193 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27193 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27193, 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 "__triples" t0 WHERE t0.p = 27194;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27194 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27194 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27194, 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 "__triples" t0 WHERE t0.p = 27195;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27195 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27195 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27195, 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 "__triples" t0 WHERE t0.p = 27196;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27196 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27196 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27196, 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 27197;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 27197);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27197 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 "__triples" t0 WHERE t0.p = 27198;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27198 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27198 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27198, 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 "__triples" t0 WHERE t0.p = 27199;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27199 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27199 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27199, 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 "__triples" t0 WHERE t0.p = 27200;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27200 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27200 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27200, 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 "__triples" t0 WHERE t0.p = 27201;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27201 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27201 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27201, 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 "__triples" t0 WHERE t0.p = 27202;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27202 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27202 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27202, 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 "__triples" t0 WHERE t0.p = 27203;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27203 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27203 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27203, 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 "__triples" t0 WHERE t0.p = 27204;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27204 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27204 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27204, 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 "__triples" t0 WHERE t0.p = 27205;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27205 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27205 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27205, 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 "__triples" t0 WHERE t0.p = 27206;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27206 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27206 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27206, 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 "__triples" t0 WHERE t0.p = 27207;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27207 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27207 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27207, 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 "__triples" t0 WHERE t0.p = 27208;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27208 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27208 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27208, 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 "__triples" t0 WHERE t0.p = 27209;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27209 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27209 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27209, 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 "__triples" t0 WHERE t0.p = 27210;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27210 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27210 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27210, 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 "__triples" t0 WHERE t0.p = 27211;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27211 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27211 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27211, 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 "__triples" t0 WHERE t0.p = 27212;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27212 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27212 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27212, 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 "__triples" t0 WHERE t0.p = 27213;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27213 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27213 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27213, 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 "__triples" t0 WHERE t0.p = 27214;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27214 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27214 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27214, 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 "__triples" t0 WHERE t0.p = 27215;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27215 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27215 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27215, 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 "__triples" t0 WHERE t0.p = 27216;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27216 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27216 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27216, 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 "__triples" t0 WHERE t0.p = 27217;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27217 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27217 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27217, 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 "__triples" t0 WHERE t0.p = 27218;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27218 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27218 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27218, 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 "__triples" t0 WHERE t0.p = 27219;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27219 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27219 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27219, 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 "__triples" t0 WHERE t0.p = 27220;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27220 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27220 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27220, 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 27221;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 27221);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27221 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 "__triples" t0 WHERE t0.p = 27222;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27222 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27222 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27222, 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 27223;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 27223);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27223 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 "__triples" t0 WHERE t0.p = 27224;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27224 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27224 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27224, 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 "__triples" t0 WHERE t0.p = 27225;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27225 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27225 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27225, 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 "__triples" t0 WHERE t0.p = 27226;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27226 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27226 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27226, 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 "__triples" t0 WHERE t0.p = 27227;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27227 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27227 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27227, 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 "__triples" t0 WHERE t0.p = 27228;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27228 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27228 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27228, 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 "__triples" t0 WHERE t0.p = 27229;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27229 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27229 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27229, 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 "__triples" t0 WHERE t0.p = 27230;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27230 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27230 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27230, 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 "__triples" t0 WHERE t0.p = 27231;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27231 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27231 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27231, 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 "__triples" t0 WHERE t0.p = 27232;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27232 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27232 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27232, 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 "__triples" t0 WHERE t0.p = 27233;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27233 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27233 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27233, 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 "__triples" t0 WHERE t0.p = 27234;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27234 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27234 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27234, 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 "__triples" t0 WHERE t0.p = 27235;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27235 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27235 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27235, 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 "__triples" t0 WHERE t0.p = 27236;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27236 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27236 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27236, 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 "__triples" t0 WHERE t0.p = 27237;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27237 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27237 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27237, 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 "__triples" t0 WHERE t0.p = 27238;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27238 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27238 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27238, 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 "__triples" t0 WHERE t0.p = 27239;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27239 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27239 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27239, 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 "__triples" t0 WHERE t0.p = 27240;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27240 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27240 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27240, 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 "__triples" t0 WHERE t0.p = 27241;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27241 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27241 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27241, 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 27242;
    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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 27243;
    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 "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27242);


        -- <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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 27242);


        -- <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 "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27243);


        -- <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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 27243);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27242 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27243 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 "__triples" t0 WHERE t0.p = 27244;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27244 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27244 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27244, 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 "__triples" t0 WHERE t0.p = 27245;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27245 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27245 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27245, 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 "__triples" t0 WHERE t0.p = 27246;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27246 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27246 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27246, 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 "__triples" t0 WHERE t0.p = 27247;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27247 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27247 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27247, 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 "__triples" t0 WHERE t0.p = 27248;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27248 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27248 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27248, 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 "__triples" t0 WHERE t0.p = 27249;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27249 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27249 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27249, 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 "__triples" t0 WHERE t0.p = 27250;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27250 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27250 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27250, 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 "__triples" t0 WHERE t0.p = 27251;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27251 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27251 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27251, 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 "__triples" t0 WHERE t0.p = 27252;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27252 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27252 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27252, 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 "__triples" t0 WHERE t0.p = 27253;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27253 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27253 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27253, 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 "__triples" t0 WHERE t0.p = 27254;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27254 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27254 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27254, 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 "__triples" t0 WHERE t0.p = 27255;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27255 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27255 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27255, 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 "__triples" t0 WHERE t0.p = 27256;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27256 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27256 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27256, 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 "__triples" t0 WHERE t0.p = 27257;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27257 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27257 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27257, 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 "__triples" t0 WHERE t0.p = 27258;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27258 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27258 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27258, 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 "__triples" t0 WHERE t0.p = 27259;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27259 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27259 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27259, 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 "__triples" t0 WHERE t0.p = 27260;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27260 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27260 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27260, 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 "__triples" t0 WHERE t0.p = 27261;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27261 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27261 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27261, 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 27262;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 27262);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27262 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 "__triples" t0 WHERE t0.p = 27263;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27263 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27263 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27263, 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 "__triples" t0 WHERE t0.p = 27264;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27264 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27264 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27264, 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27265 FROM "__triples" t0 WHERE t0.p = 27264 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27265);
    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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 27265;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 27265);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27265 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 "__triples" t0 WHERE t0.p = 27266;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27266 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27266 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27266, 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 "__triples" t0 WHERE t0.p = 27267;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27267 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27267 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27267, 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 "__triples" t0 WHERE t0.p = 27268;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27268 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27268 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27268, 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 "__triples" t0 WHERE t0.p = 27269;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27269 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27269 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27269, 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 27270;
    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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 27271;
    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 "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27270);


        -- <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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 27270);


        -- <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 "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27271);


        -- <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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 27271);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27270 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27271 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 "__triples" t0 WHERE t0.p = 27272;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27272 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27272 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27272, 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 "__triples" t0 WHERE t0.p = 27273;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27273 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27273 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27273, 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 "__triples" t0 WHERE t0.p = 27274;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27274 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27274 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27274, 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 "__triples" t0 WHERE t0.p = 27275;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27275 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27275 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27275, 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 27276;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 27276);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27276 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 "__triples" t0 WHERE t0.p = 27277;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27277 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27277 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27277, 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 "__triples" t0 WHERE t0.p = 27278;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27278 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27278 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27278, 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 "__triples" t0 WHERE t0.p = 27279;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27279 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27279 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27279, 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 "__triples" t0 WHERE t0.p = 27280;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27280 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27280 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27280, 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27282 FROM "__triples" t0 WHERE t0.p = 27192 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27282);
    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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 27281;
    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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 27282;
    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 "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27281);


        -- <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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 27281);


        -- <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 "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27282);


        -- <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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 27282);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27281 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27282 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 "__triples" t0 WHERE t0.p = 27283;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27283 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27283 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27283, 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 "__triples" t0 WHERE t0.p = 27284;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27284 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27284 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27284, 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 "__triples" t0 WHERE t0.p = 27285;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27285 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27285 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27285, 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 "__triples" t0 WHERE t0.p = 27286;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27286 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27286 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27286, 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 "__triples" t0 WHERE t0.p = 27287;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27287 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27287 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27287, 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 "__triples" t0 WHERE t0.p = 27288;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27288 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27288 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27288, 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 "__triples" t0 WHERE t0.p = 27289;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27289 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27289 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27289, 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 "__triples" t0 WHERE t0.p = 27290;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27290 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27290 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27290, 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 "__triples" t0 WHERE t0.p = 27291;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27291 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27291 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27291, 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 "__triples" t0 WHERE t0.p = 27292;
    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) .
