        INSERT INTO "dbrdf_eTeatrId_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_eTeatrId_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27630 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1144
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_highestRank_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_highestRank_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27631;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_highestRank_delta_old" ON "dbrdf_highestRank_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_highestRank_delta_old" ON "dbrdf_highestRank_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_highestRank_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1145
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rankingsSingles_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rankingsSingles_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27632;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rankingsSingles_delta_old" ON "dbrdf_rankingsSingles_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rankingsSingles_delta_old" ON "dbrdf_rankingsSingles_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rankingsSingles_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1146
    ---- DEPENDS ON: 1145, 886, 833, 647, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/TennisPlayer>(?X) :- <http://dbpedia.org/ontology/rankingsSingles>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27633 FROM "__triples" t0 WHERE t0.p = 27632 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27633);
    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_TennisPlayer_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_TennisPlayer_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27633;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_TennisPlayer_delta_old" ON "dbrdf_TennisPlayer_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_TennisPlayer_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/TennisPlayer$delta_new>(?Y) :- <http://dbpedia.org/ontology/TennisPlayer$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_TennisPlayer_delta_new"(s) SELECT t1.o FROM "dbrdf_TennisPlayer_delta_old" t0, "__triples" t1 WHERE 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 = 27633);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1147
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_retired_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_retired_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27634;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_retired_delta_old" ON "dbrdf_retired_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_retired_delta_old" ON "dbrdf_retired_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_retired_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1148
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_gross_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_gross_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27635;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_gross_delta_old" ON "dbrdf_gross_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_gross_delta_old" ON "dbrdf_gross_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_gross_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1149
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_MixedMartialArtsLeague_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_MixedMartialArtsLeague_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27636;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_MixedMartialArtsLeague_delta_old" ON "dbrdf_MixedMartialArtsLeague_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_MixedMartialArtsLeague_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/MixedMartialArtsLeague$delta_new>(?Y) :- <http://dbpedia.org/ontology/MixedMartialArtsLeague$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_MixedMartialArtsLeague_delta_new"(s) SELECT t1.o FROM "dbrdf_MixedMartialArtsLeague_delta_old" t0, "__triples" t1 WHERE 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 = 27636);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1150
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cmpEvaDuration_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cmpEvaDuration_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27637;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cmpEvaDuration_delta_old0" ON "dbrdf_cmpEvaDuration_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_cmpEvaDuration_delta_old0" ON "dbrdf_cmpEvaDuration_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cmpEvaDuration_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/cmpEvaDuration$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/cmpEvaDuration$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_cmpEvaDuration_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_cmpEvaDuration_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 = 27637 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/cmpEvaDuration$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/cmpEvaDuration$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_cmpEvaDuration_delta_new0"(s, o) SELECT t0.s, t1.o FROM "dbrdf_cmpEvaDuration_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 = 27637 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27637, t0.o FROM "dbrdf_cmpEvaDuration_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_cmpEvaDuration_delta_old0";
        INSERT INTO "dbrdf_cmpEvaDuration_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cmpEvaDuration_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_cmpEvaDuration_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1151
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfWineries_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfWineries_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27638;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfWineries_delta_old" ON "dbrdf_numberOfWineries_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfWineries_delta_old" ON "dbrdf_numberOfWineries_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfWineries_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1152
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_canonizedBy_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_canonizedBy_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27639;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_canonizedBy_delta_old" ON "dbrdf_canonizedBy_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_canonizedBy_delta_old" ON "dbrdf_canonizedBy_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_canonizedBy_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfMembersAsOf_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfMembersAsOf_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27640;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfMembersAsOf_delta_old" ON "dbrdf_numberOfMembersAsOf_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfMembersAsOf_delta_old" ON "dbrdf_numberOfMembersAsOf_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfMembersAsOf_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_trainer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_trainer_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27641;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_trainer_delta_old" ON "dbrdf_trainer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_trainer_delta_old" ON "dbrdf_trainer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_trainer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1155
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfVolunteers_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfVolunteers_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27642;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfVolunteers_delta_old" ON "dbrdf_numberOfVolunteers_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfVolunteers_delta_old" ON "dbrdf_numberOfVolunteers_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfVolunteers_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftRecon_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftRecon_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27643;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftRecon_delta_old" ON "dbrdf_aircraftRecon_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftRecon_delta_old" ON "dbrdf_aircraftRecon_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftRecon_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_coastLine_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_coastLine_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27644;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_coastLine_delta_old" ON "dbrdf_coastLine_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_coastLine_delta_old" ON "dbrdf_coastLine_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_coastLine_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1158
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_europeanParliamentGroup_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_europeanParliamentGroup_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27645;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_europeanParliamentGroup_delta_old" ON "dbrdf_europeanParliamentGroup_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_europeanParliamentGroup_delta_old" ON "dbrdf_europeanParliamentGroup_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_europeanParliamentGroup_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1159
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_militaryRank_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_militaryRank_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27646;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_militaryRank_delta_old" ON "dbrdf_militaryRank_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_militaryRank_delta_old" ON "dbrdf_militaryRank_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_militaryRank_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1160
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_demolitionYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_demolitionYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27647;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_demolitionYear_delta_old" ON "dbrdf_demolitionYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_demolitionYear_delta_old" ON "dbrdf_demolitionYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_demolitionYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1161
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_layout_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_layout_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27648;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_layout_delta_old" ON "dbrdf_layout_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_layout_delta_old" ON "dbrdf_layout_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_layout_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1162
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_supplementalDraftRound_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_supplementalDraftRound_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27649;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_supplementalDraftRound_delta_old" ON "dbrdf_supplementalDraftRound_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_supplementalDraftRound_delta_old" ON "dbrdf_supplementalDraftRound_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_supplementalDraftRound_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1163
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_staff_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_staff_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27650;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_staff_delta_old" ON "dbrdf_staff_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_staff_delta_old" ON "dbrdf_staff_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_staff_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1164
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_casNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_casNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27651;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_casNumber_delta_old" ON "dbrdf_casNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_casNumber_delta_old" ON "dbrdf_casNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_casNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1165
    ---- DEPENDS ON: 1164, 548, 388, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/ChemicalCompound$delta_new>(?Y) :- <http://dbpedia.org/ontology/ChemicalCompound$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_ChemicalCompound_delta_new"(s) SELECT t1.o FROM "dbrdf_ChemicalCompound_delta_old" t0, "__triples" t1 WHERE 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 = 27652);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_eloRecord_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_eloRecord_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27653;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_eloRecord_delta_old" ON "dbrdf_eloRecord_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_eloRecord_delta_old" ON "dbrdf_eloRecord_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_eloRecord_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1167
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Sculpture_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Sculpture_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27654;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Sculpture_delta_old" ON "dbrdf_Sculpture_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Sculpture_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Sculpture_delta_old0"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Sculpture_delta_old0"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27655;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Sculpture_delta_old0" ON "dbrdf_Sculpture_delta_old0"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Sculpture_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/Sculpture$delta_new>(?X) :- <http://schema.org/Sculpture$delta_old>(?X) .
        INSERT INTO "dbrdf_Sculpture_delta_new"(s) SELECT t0.s FROM "dbrdf_Sculpture_delta_old0" t0 WHERE NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27654);


        -- <http://dbpedia.org/ontology/Sculpture$delta_new>(?Y) :- <http://dbpedia.org/ontology/Sculpture$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Sculpture_delta_new"(s) SELECT t1.o FROM "dbrdf_Sculpture_delta_old" t0, "__triples" t1 WHERE 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 = 27654);


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


        -- <http://schema.org/Sculpture$delta_new>(?Y) :- <http://schema.org/Sculpture$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Sculpture_delta_new0"(s) SELECT t1.o FROM "dbrdf_Sculpture_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 = 27655);


        -- Propagate $delta_new

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

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27655 FROM "dbrdf_Sculpture_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_Sculpture_delta_old0";
        INSERT INTO "dbrdf_Sculpture_delta_old0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Sculpture_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_Sculpture_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1168
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_previousEditor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_previousEditor_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27656;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_previousEditor_delta_old" ON "dbrdf_previousEditor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_previousEditor_delta_old" ON "dbrdf_previousEditor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_previousEditor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1169
    ---- DEPENDS ON: 1168, 452, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- [Rule] <http://dbpedia.org/ontology/Magazine>(?X) :- <http://dbpedia.org/ontology/previousEditor>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27657 FROM "__triples" t0 WHERE t0.p = 27656 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27657);
    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_Magazine_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Magazine_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27657;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Magazine_delta_old" ON "dbrdf_Magazine_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Magazine_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/Magazine$delta_new>(?Y) :- <http://dbpedia.org/ontology/Magazine$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Magazine_delta_new"(s) SELECT t1.o FROM "dbrdf_Magazine_delta_old" t0, "__triples" t1 WHERE 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 = 27657);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1170
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_crewMember_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_crewMember_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27658;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_crewMember_delta_old" ON "dbrdf_crewMember_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_crewMember_delta_old" ON "dbrdf_crewMember_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_crewMember_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1171
    ---- DEPENDS ON: 1170, 1105, 839, 122, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Astronaut>(?X) :- <http://dbpedia.org/ontology/selection>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27659 FROM "__triples" t0 WHERE t0.p = 26604 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27659);
    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_Astronaut_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Astronaut_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27659;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Astronaut_delta_old" ON "dbrdf_Astronaut_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Astronaut_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Astronaut$delta_new>(?Y) :- <http://dbpedia.org/ontology/Astronaut$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Astronaut_delta_new"(s) SELECT t1.o FROM "dbrdf_Astronaut_delta_old" t0, "__triples" t1 WHERE 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 = 27659);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1172
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_crew_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_crew_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27660;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_crew_delta_old" ON "dbrdf_crew_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_crew_delta_old" ON "dbrdf_crew_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_crew_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Bird$delta_new>(?Y) :- <http://dbpedia.org/ontology/Bird$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Bird_delta_new"(s) SELECT t1.o FROM "dbrdf_Bird_delta_old" t0, "__triples" t1 WHERE 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 = 27665);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_averageSpeed_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_averageSpeed_delta_old1"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27669;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_averageSpeed_delta_old1" ON "dbrdf_averageSpeed_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_averageSpeed_delta_old1" ON "dbrdf_averageSpeed_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_averageSpeed_delta_new1"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Nonrecursive rules

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Song_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Song_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27670;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Song_delta_old" ON "dbrdf_Song_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Song_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_MusicRecording_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_MusicRecording_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27671;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_MusicRecording_delta_old" ON "dbrdf_MusicRecording_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_MusicRecording_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Song$delta_new>(?X) :- <http://schema.org/MusicRecording$delta_old>(?X) .
        INSERT INTO "dbrdf_Song_delta_new"(s) SELECT t0.s FROM "dbrdf_MusicRecording_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27670);


        -- <http://dbpedia.org/ontology/Song$delta_new>(?Y) :- <http://dbpedia.org/ontology/Song$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Song_delta_new"(s) SELECT t1.o FROM "dbrdf_Song_delta_old" t0, "__triples" t1 WHERE 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 = 27670);


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


        -- <http://schema.org/MusicRecording$delta_new>(?Y) :- <http://schema.org/MusicRecording$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_MusicRecording_delta_new"(s) SELECT t1.o FROM "dbrdf_MusicRecording_delta_old" t0, "__triples" t1 WHERE 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 = 27671);


        -- Propagate $delta_new

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

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1183
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_appearancesInLeague_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_appearancesInLeague_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27672;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_appearancesInLeague_delta_old" ON "dbrdf_appearancesInLeague_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_appearancesInLeague_delta_old" ON "dbrdf_appearancesInLeague_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_appearancesInLeague_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1184
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1189
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_metropolitanBorough_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_metropolitanBorough_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27678;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_metropolitanBorough_delta_old" ON "dbrdf_metropolitanBorough_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_metropolitanBorough_delta_old" ON "dbrdf_metropolitanBorough_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_metropolitanBorough_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1190
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_freeFlightTime_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_freeFlightTime_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27679;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_freeFlightTime_delta_old0" ON "dbrdf_freeFlightTime_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_freeFlightTime_delta_old0" ON "dbrdf_freeFlightTime_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_freeFlightTime_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/CurlingLeague$delta_new>(?Y) :- <http://dbpedia.org/ontology/CurlingLeague$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_CurlingLeague_delta_new"(s) SELECT t1.o FROM "dbrdf_CurlingLeague_delta_old" t0, "__triples" t1 WHERE 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 = 27682);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/GolfLeague$delta_new>(?Y) :- <http://dbpedia.org/ontology/GolfLeague$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_GolfLeague_delta_new"(s) SELECT t1.o FROM "dbrdf_GolfLeague_delta_old" t0, "__triples" t1 WHERE 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 = 27683);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationUrbanDensity_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_populationUrbanDensity_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27685;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_populationUrbanDensity_delta_old0" ON "dbrdf_populationUrbanDensity_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_populationUrbanDensity_delta_old0" ON "dbrdf_populationUrbanDensity_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationUrbanDensity_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Nonrecursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/NationalCollegiateAthleticAssociationAthlete$delta_new>(?Y) :- <http://dbpedia.org/ontology/NationalCollegiateAthleticAssociationAthlete$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_NationalCollegiateAthleticAssociationAthlete_delta_new"(s) SELECT t1.o FROM "dbrdf_NationalCollegiateAthleticAssociationAthlete_delta_old" t0, "__triples" t1 WHERE 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 = 27686);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Nonrecursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Cave$delta_new>(?Y) :- <http://dbpedia.org/ontology/Cave$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Cave_delta_new"(s) SELECT t1.o FROM "dbrdf_Cave_delta_old" t0, "__triples" t1 WHERE 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 = 27690);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1204
    ---- DEPENDS ON: 545, 243, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Artery$delta_new>(?Y) :- <http://dbpedia.org/ontology/Artery$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Artery_delta_new"(s) SELECT t1.o FROM "dbrdf_Artery_delta_old" t0, "__triples" t1 WHERE 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 = 27693);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1205
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_runtime_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_runtime_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27697;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_runtime_delta_old0" ON "dbrdf_runtime_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_runtime_delta_old0" ON "dbrdf_runtime_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_runtime_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1209
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_municipalityCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_municipalityCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27698;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_municipalityCode_delta_old" ON "dbrdf_municipalityCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_municipalityCode_delta_old" ON "dbrdf_municipalityCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_municipalityCode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1210
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1211
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_yearOfConstruction_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_yearOfConstruction_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27700;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_yearOfConstruction_delta_old" ON "dbrdf_yearOfConstruction_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_yearOfConstruction_delta_old" ON "dbrdf_yearOfConstruction_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_yearOfConstruction_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1212
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Journalist$delta_new>(?Y) :- <http://dbpedia.org/ontology/Journalist$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Journalist_delta_new"(s) SELECT t1.o FROM "dbrdf_Journalist_delta_old" t0, "__triples" t1 WHERE 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 = 27704);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1218
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_originalMaximumBoatBeam_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_originalMaximumBoatBeam_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27707;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_originalMaximumBoatBeam_delta_old0" ON "dbrdf_originalMaximumBoatBeam_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_originalMaximumBoatBeam_delta_old0" ON "dbrdf_originalMaximumBoatBeam_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_originalMaximumBoatBeam_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1219
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumTemperature_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_maximumTemperature_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27715;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_maximumTemperature_delta_old0" ON "dbrdf_maximumTemperature_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_maximumTemperature_delta_old0" ON "dbrdf_maximumTemperature_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumTemperature_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaUrban_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_areaUrban_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27724;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_areaUrban_delta_old0" ON "dbrdf_areaUrban_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_areaUrban_delta_old0" ON "dbrdf_areaUrban_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaUrban_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Nonrecursive rules

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

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/FormulaOneRacing$delta_new>(?Y) :- <http://dbpedia.org/ontology/FormulaOneRacing$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_FormulaOneRacing_delta_new"(s) SELECT t1.o FROM "dbrdf_FormulaOneRacing_delta_old" t0, "__triples" t1 WHERE 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 = 27726);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Conifer$delta_new>(?Y) :- <http://dbpedia.org/ontology/Conifer$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Conifer_delta_new"(s) SELECT t1.o FROM "dbrdf_Conifer_delta_old" t0, "__triples" t1 WHERE 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 = 27741);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_wheelbase_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_wheelbase_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27746;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_wheelbase_delta_old0" ON "dbrdf_wheelbase_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_wheelbase_delta_old0" ON "dbrdf_wheelbase_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_wheelbase_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Nonrecursive rules

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/PublicTransitSystem$delta_new>(?Y) :- <http://dbpedia.org/ontology/PublicTransitSystem$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_PublicTransitSystem_delta_new"(s) SELECT t1.o FROM "dbrdf_PublicTransitSystem_delta_old" t0, "__triples" t1 WHERE 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 = 27748);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Nonrecursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/WorldHeritageSite$delta_new>(?Y) :- <http://dbpedia.org/ontology/WorldHeritageSite$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_WorldHeritageSite_delta_new"(s) SELECT t1.o FROM "dbrdf_WorldHeritageSite_delta_old" t0, "__triples" t1 WHERE 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 = 27753);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lunarSampleMass_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lunarSampleMass_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27756;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lunarSampleMass_delta_old0" ON "dbrdf_lunarSampleMass_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_lunarSampleMass_delta_old0" ON "dbrdf_lunarSampleMass_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lunarSampleMass_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Nonrecursive rules

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

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

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Gene$delta_new>(?Y) :- <http://dbpedia.org/ontology/Gene$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Gene_delta_new"(s) SELECT t1.o FROM "dbrdf_Gene_delta_old" t0, "__triples" t1 WHERE 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 = 27763);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1277
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_fileSize_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_fileSize_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27766;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_fileSize_delta_old0" ON "dbrdf_fileSize_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_fileSize_delta_old0" ON "dbrdf_fileSize_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_fileSize_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1278
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationMetroDensity_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_populationMetroDensity_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27770;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_populationMetroDensity_delta_old0" ON "dbrdf_populationMetroDensity_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_populationMetroDensity_delta_old0" ON "dbrdf_populationMetroDensity_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationMetroDensity_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Surname$delta_new>(?Y) :- <http://dbpedia.org/ontology/Surname$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Surname_delta_new"(s) SELECT t1.o FROM "dbrdf_Surname_delta_old" t0, "__triples" t1 WHERE 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 = 27775);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumBoatBeam_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_maximumBoatBeam_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27777;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_maximumBoatBeam_delta_old0" ON "dbrdf_maximumBoatBeam_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_maximumBoatBeam_delta_old0" ON "dbrdf_maximumBoatBeam_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumBoatBeam_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Nonrecursive rules

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Painting_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Painting_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27782;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Painting_delta_old" ON "dbrdf_Painting_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Painting_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Painting_delta_old0"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Painting_delta_old0"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27783;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Painting_delta_old0" ON "dbrdf_Painting_delta_old0"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Painting_delta_new0"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- <http://schema.org/Painting$delta_new>(?Y) :- <http://schema.org/Painting$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Painting_delta_new"(s) SELECT t1.o FROM "dbrdf_Painting_delta_old" t0, "__triples" t1 WHERE 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 = 27782);


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


        -- <http://dbpedia.org/ontology/Painting$delta_new>(?Y) :- <http://dbpedia.org/ontology/Painting$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Painting_delta_new0"(s) SELECT t1.o FROM "dbrdf_Painting_delta_old0" t0, "__triples" t1 WHERE 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 = 27783);


        -- Propagate $delta_new

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

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

    END LOOP;

    -- END Recursive rules

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

    -- Nonrecursive rules

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Instrument$delta_new>(?Y) :- <http://dbpedia.org/ontology/Instrument$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Instrument_delta_new"(s) SELECT t1.o FROM "dbrdf_Instrument_delta_old" t0, "__triples" t1 WHERE 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 = 27784);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_temperature_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_temperature_delta_old1"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27785;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_temperature_delta_old1" ON "dbrdf_temperature_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_temperature_delta_old1" ON "dbrdf_temperature_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_temperature_delta_new1"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Nonrecursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/LunarCrater$delta_new>(?Y) :- <http://dbpedia.org/ontology/LunarCrater$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_LunarCrater_delta_new"(s) SELECT t1.o FROM "dbrdf_LunarCrater_delta_old" t0, "__triples" t1 WHERE 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 = 27787);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Nonrecursive rules

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/FilmFestival$delta_new>(?Y) :- <http://dbpedia.org/ontology/FilmFestival$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_FilmFestival_delta_new"(s) SELECT t1.o FROM "dbrdf_FilmFestival_delta_old" t0, "__triples" t1 WHERE 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 = 27790);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27795, t0.o FROM "dbrdf_composer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
