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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lunarLandingSite_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lunarLandingSite_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27796;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lunarLandingSite_delta_old" ON "dbrdf_lunarLandingSite_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lunarLandingSite_delta_old" ON "dbrdf_lunarLandingSite_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lunarLandingSite_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_soccerTournamentOpeningSeason_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_soccerTournamentOpeningSeason_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27799;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_soccerTournamentOpeningSeason_delta_old" ON "dbrdf_soccerTournamentOpeningSeason_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_soccerTournamentOpeningSeason_delta_old" ON "dbrdf_soccerTournamentOpeningSeason_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_soccerTournamentOpeningSeason_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_startPoint_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_startPoint_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27803;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_startPoint_delta_old" ON "dbrdf_startPoint_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_startPoint_delta_old" ON "dbrdf_startPoint_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_startPoint_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dockedTime_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dockedTime_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27805;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dockedTime_delta_old0" ON "dbrdf_dockedTime_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_dockedTime_delta_old0" ON "dbrdf_dockedTime_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dockedTime_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27805, t0.o FROM "dbrdf_dockedTime_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_dockedTime_delta_old0";
        INSERT INTO "dbrdf_dockedTime_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_dockedTime_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_dockedTime_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1316
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_latestPreviewVersion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_latestPreviewVersion_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27806;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_latestPreviewVersion_delta_old" ON "dbrdf_latestPreviewVersion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_latestPreviewVersion_delta_old" ON "dbrdf_latestPreviewVersion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_latestPreviewVersion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1317
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27808, t0.o FROM "dbrdf_course_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_course_delta_old0";
        INSERT INTO "dbrdf_course_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_course_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_course_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1319
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1324
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_area_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_area_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27815;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_area_delta_old0" ON "dbrdf_area_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_area_delta_old0" ON "dbrdf_area_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_area_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_jstor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_jstor_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27816;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_jstor_delta_old" ON "dbrdf_jstor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_jstor_delta_old" ON "dbrdf_jstor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_jstor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_runwayLength_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_runwayLength_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27817;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_runwayLength_delta_old" ON "dbrdf_runwayLength_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_runwayLength_delta_old" ON "dbrdf_runwayLength_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_runwayLength_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_distributor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_distributor_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27818;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_distributor_delta_old" ON "dbrdf_distributor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_distributor_delta_old" ON "dbrdf_distributor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_distributor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationTotal_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_populationTotal_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27819;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_populationTotal_delta_old" ON "dbrdf_populationTotal_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_populationTotal_delta_old" ON "dbrdf_populationTotal_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationTotal_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_bustSize_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_bustSize_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27820;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_bustSize_delta_old" ON "dbrdf_bustSize_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_bustSize_delta_old" ON "dbrdf_bustSize_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_bustSize_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1331
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winterAppearances_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winterAppearances_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27821;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winterAppearances_delta_old" ON "dbrdf_winterAppearances_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winterAppearances_delta_old" ON "dbrdf_winterAppearances_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winterAppearances_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1332
    ---- DEPENDS ON: 1164, 1023, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- [Rule] <http://dbpedia.org/ontology/LawFirm>(?X) :- <http://dbpedia.org/ontology/numberOfLawyers>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27822 FROM "__triples" t0 WHERE t0.p = 27650 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27822);
    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_LawFirm_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_LawFirm_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27822;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_LawFirm_delta_old" ON "dbrdf_LawFirm_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_LawFirm_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/LawFirm$delta_new>(?Y) :- <http://dbpedia.org/ontology/LawFirm$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_LawFirm_delta_new"(s) SELECT t1.o FROM "dbrdf_LawFirm_delta_old" t0, "__triples" t1 WHERE 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 = 27822);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_hgncid_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_hgncid_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27823;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_hgncid_delta_old" ON "dbrdf_hgncid_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_hgncid_delta_old" ON "dbrdf_hgncid_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_hgncid_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_battleHonours_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_battleHonours_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27824;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_battleHonours_delta_old" ON "dbrdf_battleHonours_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_battleHonours_delta_old" ON "dbrdf_battleHonours_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_battleHonours_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_person_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_person_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27825;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_person_delta_old" ON "dbrdf_person_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_person_delta_old" ON "dbrdf_person_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_person_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_measurements_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_measurements_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27826;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_measurements_delta_old" ON "dbrdf_measurements_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_measurements_delta_old" ON "dbrdf_measurements_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_measurements_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_organisationMember_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_organisationMember_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27827;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_organisationMember_delta_old" ON "dbrdf_organisationMember_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_organisationMember_delta_old" ON "dbrdf_organisationMember_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_organisationMember_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1338
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_statisticLabel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_statisticLabel_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27828;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_statisticLabel_delta_old" ON "dbrdf_statisticLabel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_statisticLabel_delta_old" ON "dbrdf_statisticLabel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_statisticLabel_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1339
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_incumbent_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_incumbent_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27829;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_incumbent_delta_old" ON "dbrdf_incumbent_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_incumbent_delta_old" ON "dbrdf_incumbent_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_incumbent_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1340
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nerve_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nerve_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27830;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nerve_delta_old" ON "dbrdf_nerve_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nerve_delta_old" ON "dbrdf_nerve_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nerve_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1341
    ---- DEPENDS ON: 1340, 1082, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- [Rule] <http://dbpedia.org/ontology/Nerve>(?X1) :- <http://dbpedia.org/ontology/nerve>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.o, 2, 27831 FROM "__triples" t0 WHERE t0.p = 27830 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.o AND ex.p = 2 AND ex.o = 27831);
    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_Nerve_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Nerve_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27831;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Nerve_delta_old" ON "dbrdf_Nerve_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Nerve_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/Nerve$delta_new>(?Y) :- <http://dbpedia.org/ontology/Nerve$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Nerve_delta_new"(s) SELECT t1.o FROM "dbrdf_Nerve_delta_old" t0, "__triples" t1 WHERE 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 = 27831);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1342
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1343
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_access_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_access_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27833;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_access_delta_old" ON "dbrdf_access_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_access_delta_old" ON "dbrdf_access_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_access_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1344
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfParkingSpaces_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfParkingSpaces_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27834;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfParkingSpaces_delta_old" ON "dbrdf_numberOfParkingSpaces_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfParkingSpaces_delta_old" ON "dbrdf_numberOfParkingSpaces_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfParkingSpaces_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1345
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_membership_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_membership_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27835;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_membership_delta_old" ON "dbrdf_membership_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_membership_delta_old" ON "dbrdf_membership_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_membership_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1346
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_notifyDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_notifyDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27836;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_notifyDate_delta_old" ON "dbrdf_notifyDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_notifyDate_delta_old" ON "dbrdf_notifyDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_notifyDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1347
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_buriedPlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_buriedPlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27837;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_buriedPlace_delta_old" ON "dbrdf_buriedPlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_buriedPlace_delta_old" ON "dbrdf_buriedPlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_buriedPlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1348
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cargoWater_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cargoWater_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27838;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cargoWater_delta_old0" ON "dbrdf_cargoWater_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_cargoWater_delta_old0" ON "dbrdf_cargoWater_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cargoWater_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27838, t0.o FROM "dbrdf_cargoWater_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_cargoWater_delta_old0";
        INSERT INTO "dbrdf_cargoWater_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cargoWater_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_cargoWater_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1349
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1350
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_layingDown_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_layingDown_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27840;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_layingDown_delta_old" ON "dbrdf_layingDown_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_layingDown_delta_old" ON "dbrdf_layingDown_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_layingDown_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1351
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mission_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mission_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27841;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mission_delta_old" ON "dbrdf_mission_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mission_delta_old" ON "dbrdf_mission_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mission_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1352
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_oldcode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_oldcode_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27842;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_oldcode_delta_old" ON "dbrdf_oldcode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_oldcode_delta_old" ON "dbrdf_oldcode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_oldcode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1353
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_stationStructure_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_stationStructure_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27843;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_stationStructure_delta_old" ON "dbrdf_stationStructure_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_stationStructure_delta_old" ON "dbrdf_stationStructure_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_stationStructure_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1354
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_purpose_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_purpose_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27844;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_purpose_delta_old" ON "dbrdf_purpose_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_purpose_delta_old" ON "dbrdf_purpose_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_purpose_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1355
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstDriverTeam_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstDriverTeam_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27845;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstDriverTeam_delta_old" ON "dbrdf_firstDriverTeam_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstDriverTeam_delta_old" ON "dbrdf_firstDriverTeam_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstDriverTeam_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1356
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_brainInfoType_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_brainInfoType_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27846;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_brainInfoType_delta_old" ON "dbrdf_brainInfoType_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_brainInfoType_delta_old" ON "dbrdf_brainInfoType_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_brainInfoType_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1357
    ---- DEPENDS ON: 1356, 1322, 1269, 817, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Brain>(?X) :- <http://dbpedia.org/ontology/component>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27847 FROM "__triples" t0 WHERE t0.p = 27812 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27847);
    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_Brain_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Brain_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27847;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Brain_delta_old" ON "dbrdf_Brain_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Brain_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/Brain$delta_new>(?Y) :- <http://dbpedia.org/ontology/Brain$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Brain_delta_new"(s) SELECT t1.o FROM "dbrdf_Brain_delta_old" t0, "__triples" t1 WHERE 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 = 27847);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1358
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_animal_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_animal_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27848;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_animal_delta_old" ON "dbrdf_animal_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_animal_delta_old" ON "dbrdf_animal_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_animal_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1359
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_academicAdvisor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_academicAdvisor_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27849;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_academicAdvisor_delta_old" ON "dbrdf_academicAdvisor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_academicAdvisor_delta_old" ON "dbrdf_academicAdvisor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_academicAdvisor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1360
    ---- DEPENDS ON: 1359, 1285, 1021, 225, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Scientist>(?X) :- <http://dbpedia.org/ontology/doctoralAdvisor>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27850 FROM "__triples" t0 WHERE t0.p = 26707 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27850);
    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_Scientist_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Scientist_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27850;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Scientist_delta_old" ON "dbrdf_Scientist_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Scientist_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/Scientist$delta_new>(?Y) :- <http://dbpedia.org/ontology/Scientist$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Scientist_delta_new"(s) SELECT t1.o FROM "dbrdf_Scientist_delta_old" t0, "__triples" t1 WHERE 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 = 27850);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1361
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1362
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtProTournaments_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtProTournaments_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27852;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtProTournaments_delta_old" ON "dbrdf_winsAtProTournaments_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtProTournaments_delta_old" ON "dbrdf_winsAtProTournaments_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtProTournaments_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1363
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_detectionMethod_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_detectionMethod_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27853;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_detectionMethod_delta_old" ON "dbrdf_detectionMethod_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_detectionMethod_delta_old" ON "dbrdf_detectionMethod_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_detectionMethod_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1364
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1365
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_productionEndDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_productionEndDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27855;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_productionEndDate_delta_old" ON "dbrdf_productionEndDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_productionEndDate_delta_old" ON "dbrdf_productionEndDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_productionEndDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1366
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_careerPrizeMoney_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_careerPrizeMoney_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27856;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_careerPrizeMoney_delta_old" ON "dbrdf_careerPrizeMoney_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_careerPrizeMoney_delta_old" ON "dbrdf_careerPrizeMoney_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_careerPrizeMoney_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1367
    ---- DEPENDS ON: 1366, 1205, 1100, 410, 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, 27857 FROM "__triples" t0 WHERE t0.p = 27856 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27857);
    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, 27857 FROM "__triples" t0 WHERE t0.p = 27586 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27857);
    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, 27857 FROM "__triples" t0 WHERE t0.p = 27691 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27857);
    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, 27857 FROM "__triples" t0 WHERE t0.p = 26892 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27857);
    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 = 27857;
    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 = 27857);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27857 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 1368
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_complexion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_complexion_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27858;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_complexion_delta_old" ON "dbrdf_complexion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_complexion_delta_old" ON "dbrdf_complexion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_complexion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1369
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_inflow_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_inflow_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27859;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_inflow_delta_old" ON "dbrdf_inflow_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_inflow_delta_old" ON "dbrdf_inflow_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_inflow_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1370
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_speaker_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_speaker_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27860;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_speaker_delta_old" ON "dbrdf_speaker_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_speaker_delta_old" ON "dbrdf_speaker_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_speaker_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1371
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27861, t0.o FROM "dbrdf_distance_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_distance_delta_old1";
        INSERT INTO "dbrdf_distance_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_distance_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_distance_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1372
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_position_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_position_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27862;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_position_delta_old" ON "dbrdf_position_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_position_delta_old" ON "dbrdf_position_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_position_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1373
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_eyeColor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_eyeColor_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27863;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_eyeColor_delta_old" ON "dbrdf_eyeColor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_eyeColor_delta_old" ON "dbrdf_eyeColor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_eyeColor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1374
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_climate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_climate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27864;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_climate_delta_old" ON "dbrdf_climate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_climate_delta_old" ON "dbrdf_climate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_climate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1375
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_hometown_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_hometown_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27865;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_hometown_delta_old" ON "dbrdf_hometown_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_hometown_delta_old" ON "dbrdf_hometown_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_hometown_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1376
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceConfluenceCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sourceConfluenceCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27866;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sourceConfluenceCountry_delta_old" ON "dbrdf_sourceConfluenceCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sourceConfluenceCountry_delta_old" ON "dbrdf_sourceConfluenceCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceConfluenceCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1377
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1378
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_length_delta_old3"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_length_delta_old3"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27868;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_length_delta_old3" ON "dbrdf_length_delta_old3"(s, o); CREATE INDEX "IDX_1_dbrdf_length_delta_old3" ON "dbrdf_length_delta_old3"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_length_delta_new3"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1379
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_routeTypeAbbreviation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_routeTypeAbbreviation_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27869;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_routeTypeAbbreviation_delta_old" ON "dbrdf_routeTypeAbbreviation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_routeTypeAbbreviation_delta_old" ON "dbrdf_routeTypeAbbreviation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_routeTypeAbbreviation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1380
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dcc_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dcc_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27870;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dcc_delta_old" ON "dbrdf_dcc_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dcc_delta_old" ON "dbrdf_dcc_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dcc_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1381
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_torchBearer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_torchBearer_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27871;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_torchBearer_delta_old" ON "dbrdf_torchBearer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_torchBearer_delta_old" ON "dbrdf_torchBearer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_torchBearer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1382
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_engineer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_engineer_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27872;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_engineer_delta_old" ON "dbrdf_engineer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_engineer_delta_old" ON "dbrdf_engineer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_engineer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1383
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_vicePrincipal_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_vicePrincipal_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27873;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_vicePrincipal_delta_old" ON "dbrdf_vicePrincipal_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_vicePrincipal_delta_old" ON "dbrdf_vicePrincipal_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_vicePrincipal_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1384
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_soccerTournamentThisSeason_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_soccerTournamentThisSeason_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27874;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_soccerTournamentThisSeason_delta_old" ON "dbrdf_soccerTournamentThisSeason_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_soccerTournamentThisSeason_delta_old" ON "dbrdf_soccerTournamentThisSeason_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_soccerTournamentThisSeason_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1385
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rankInFinalMedalCount_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rankInFinalMedalCount_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27875;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rankInFinalMedalCount_delta_old" ON "dbrdf_rankInFinalMedalCount_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rankInFinalMedalCount_delta_old" ON "dbrdf_rankInFinalMedalCount_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rankInFinalMedalCount_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1386
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_film_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_film_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27876;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_film_delta_old" ON "dbrdf_film_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_film_delta_old" ON "dbrdf_film_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_film_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1387
    ---- DEPENDS ON: 1386, 925, 299, 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, 27877 FROM "__triples" t0 WHERE t0.p = 27409 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27877);
    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, 27877 FROM "__triples" t0 WHERE t0.p = 26781 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27877);
    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, 27877 FROM "__triples" t0 WHERE t0.p = 27876 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27877);
    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 = 27877;
    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 = 27877);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27877 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 1388
    ---- DEPENDS ON: 1387, 624, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- [Rule] <http://schema.org/Festival>(?X) :- <http://dbpedia.org/ontology/FilmFestival>(?X) .
    INSERT INTO "__triples"(s, p, o) SELECT t0.s, 2, 27878 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27877 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27878);
    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_Festival_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Festival_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27878;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Festival_delta_old" ON "dbrdf_Festival_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Festival_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1389
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_absoluteMagnitude_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_absoluteMagnitude_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27879;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_absoluteMagnitude_delta_old" ON "dbrdf_absoluteMagnitude_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_absoluteMagnitude_delta_old" ON "dbrdf_absoluteMagnitude_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_absoluteMagnitude_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1390
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27880, t0.o FROM "dbrdf_cmpEvaDuration_delta_new" 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_old";
        INSERT INTO "dbrdf_cmpEvaDuration_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cmpEvaDuration_delta_new" t0;
        TRUNCATE TABLE "dbrdf_cmpEvaDuration_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1391
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_chairmanTitle_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_chairmanTitle_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27881;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_chairmanTitle_delta_old" ON "dbrdf_chairmanTitle_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_chairmanTitle_delta_old" ON "dbrdf_chairmanTitle_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_chairmanTitle_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1392
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_squadNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_squadNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27882;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_squadNumber_delta_old" ON "dbrdf_squadNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_squadNumber_delta_old" ON "dbrdf_squadNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_squadNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1393
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_domain_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_domain_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27883;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_domain_delta_old" ON "dbrdf_domain_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_domain_delta_old" ON "dbrdf_domain_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_domain_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1394
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_totalTracks_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_totalTracks_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27884;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_totalTracks_delta_old" ON "dbrdf_totalTracks_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_totalTracks_delta_old" ON "dbrdf_totalTracks_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_totalTracks_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1395
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_richestCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_richestCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27885;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_richestCountry_delta_old" ON "dbrdf_richestCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_richestCountry_delta_old" ON "dbrdf_richestCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_richestCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1396
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_shipDraft_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_shipDraft_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27886;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_shipDraft_delta_old" ON "dbrdf_shipDraft_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_shipDraft_delta_old" ON "dbrdf_shipDraft_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_shipDraft_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1397
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27887, t0.o FROM "dbrdf_missionDuration_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_missionDuration_delta_old0";
        INSERT INTO "dbrdf_missionDuration_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_missionDuration_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_missionDuration_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1398
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rgbCoordinateBlue_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rgbCoordinateBlue_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27888;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rgbCoordinateBlue_delta_old" ON "dbrdf_rgbCoordinateBlue_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rgbCoordinateBlue_delta_old" ON "dbrdf_rgbCoordinateBlue_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rgbCoordinateBlue_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1399
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_neighbourConstellations_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_neighbourConstellations_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27889;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_neighbourConstellations_delta_old" ON "dbrdf_neighbourConstellations_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_neighbourConstellations_delta_old" ON "dbrdf_neighbourConstellations_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_neighbourConstellations_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1400
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_diameter_delta_old2"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_diameter_delta_old2"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27890;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_diameter_delta_old2" ON "dbrdf_diameter_delta_old2"(s, o); CREATE INDEX "IDX_1_dbrdf_diameter_delta_old2" ON "dbrdf_diameter_delta_old2"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_diameter_delta_new2"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1401
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_routeStartLocation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_routeStartLocation_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27891;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_routeStartLocation_delta_old" ON "dbrdf_routeStartLocation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_routeStartLocation_delta_old" ON "dbrdf_routeStartLocation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_routeStartLocation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1402
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumInclination_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_maximumInclination_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27892;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_maximumInclination_delta_old" ON "dbrdf_maximumInclination_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_maximumInclination_delta_old" ON "dbrdf_maximumInclination_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumInclination_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1403
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_meetingRoad_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_meetingRoad_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27893;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_meetingRoad_delta_old" ON "dbrdf_meetingRoad_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_meetingRoad_delta_old" ON "dbrdf_meetingRoad_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_meetingRoad_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1404
    ---- DEPENDS ON: 1403, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/RoadJunction>(?X) :- <http://dbpedia.org/ontology/meetingRoad>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27894 FROM "__triples" t0 WHERE t0.p = 27893 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27894);
    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_RoadJunction_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_RoadJunction_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27894;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_RoadJunction_delta_old" ON "dbrdf_RoadJunction_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_RoadJunction_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/RoadJunction$delta_new>(?Y) :- <http://dbpedia.org/ontology/RoadJunction$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_RoadJunction_delta_new"(s) SELECT t1.o FROM "dbrdf_RoadJunction_delta_old" t0, "__triples" t1 WHERE 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 = 27894);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1405
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_specialEffects_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_specialEffects_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27895;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_specialEffects_delta_old" ON "dbrdf_specialEffects_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_specialEffects_delta_old" ON "dbrdf_specialEffects_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_specialEffects_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1406
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_soccerTournamentLastChampion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_soccerTournamentLastChampion_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27896;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_soccerTournamentLastChampion_delta_old" ON "dbrdf_soccerTournamentLastChampion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_soccerTournamentLastChampion_delta_old" ON "dbrdf_soccerTournamentLastChampion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_soccerTournamentLastChampion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1407
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_parent_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_parent_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27897;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_parent_delta_old" ON "dbrdf_parent_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_parent_delta_old" ON "dbrdf_parent_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_parent_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1408
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaMetro_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_areaMetro_delta_old1"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27898;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_areaMetro_delta_old1" ON "dbrdf_areaMetro_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_areaMetro_delta_old1" ON "dbrdf_areaMetro_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaMetro_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/PopulatedPlace/areaMetro$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/PopulatedPlace/areaMetro$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_areaMetro_delta_new1"(s, o) SELECT t1.o, t0.o FROM "dbrdf_areaMetro_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 = 27898 AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27898, t0.o FROM "dbrdf_areaMetro_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_areaMetro_delta_old1";
        INSERT INTO "dbrdf_areaMetro_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_areaMetro_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_areaMetro_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1409
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mayor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mayor_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27899;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mayor_delta_old" ON "dbrdf_mayor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mayor_delta_old" ON "dbrdf_mayor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mayor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1410
    ---- 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 = 27900;
    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 = 27900 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 = 27900 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_electionDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_electionDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27901;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_electionDate_delta_old" ON "dbrdf_electionDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_electionDate_delta_old" ON "dbrdf_electionDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_electionDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1412
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstDriverCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstDriverCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27902;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstDriverCountry_delta_old" ON "dbrdf_firstDriverCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstDriverCountry_delta_old" ON "dbrdf_firstDriverCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstDriverCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1413
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dissolutionYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dissolutionYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27903;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dissolutionYear_delta_old" ON "dbrdf_dissolutionYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dissolutionYear_delta_old" ON "dbrdf_dissolutionYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dissolutionYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1414
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_orbitalFlights_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_orbitalFlights_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27904;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_orbitalFlights_delta_old" ON "dbrdf_orbitalFlights_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_orbitalFlights_delta_old" ON "dbrdf_orbitalFlights_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_orbitalFlights_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1415
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastLaunchDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lastLaunchDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27905;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lastLaunchDate_delta_old" ON "dbrdf_lastLaunchDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lastLaunchDate_delta_old" ON "dbrdf_lastLaunchDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastLaunchDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1416
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_creativeDirector_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_creativeDirector_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27906;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_creativeDirector_delta_old" ON "dbrdf_creativeDirector_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_creativeDirector_delta_old" ON "dbrdf_creativeDirector_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_creativeDirector_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1417
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_gun_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_gun_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27907;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_gun_delta_old" ON "dbrdf_gun_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_gun_delta_old" ON "dbrdf_gun_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_gun_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1418
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_fundedBy_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_fundedBy_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27908;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_fundedBy_delta_old" ON "dbrdf_fundedBy_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_fundedBy_delta_old" ON "dbrdf_fundedBy_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_fundedBy_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1419
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_priceMoney_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_priceMoney_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27909;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_priceMoney_delta_old" ON "dbrdf_priceMoney_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_priceMoney_delta_old" ON "dbrdf_priceMoney_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_priceMoney_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1420
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mostPopulatedCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mostPopulatedCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27910;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mostPopulatedCountry_delta_old" ON "dbrdf_mostPopulatedCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mostPopulatedCountry_delta_old" ON "dbrdf_mostPopulatedCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mostPopulatedCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1421
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_regionalLanguage_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_regionalLanguage_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27911;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_regionalLanguage_delta_old" ON "dbrdf_regionalLanguage_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_regionalLanguage_delta_old" ON "dbrdf_regionalLanguage_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_regionalLanguage_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1422
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_largestCity_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_largestCity_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27912;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_largestCity_delta_old" ON "dbrdf_largestCity_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_largestCity_delta_old" ON "dbrdf_largestCity_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_largestCity_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1423
    ---- 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 = 27913;
    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 = 27913 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 = 27913 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_programmeFormat_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_programmeFormat_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27914;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_programmeFormat_delta_old" ON "dbrdf_programmeFormat_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_programmeFormat_delta_old" ON "dbrdf_programmeFormat_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_programmeFormat_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1425
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_denomination_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_denomination_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27915;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_denomination_delta_old" ON "dbrdf_denomination_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_denomination_delta_old" ON "dbrdf_denomination_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_denomination_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1426
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ecNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ecNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27916;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ecNumber_delta_old" ON "dbrdf_ecNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ecNumber_delta_old" ON "dbrdf_ecNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ecNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1427
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dorlandsSuffix_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dorlandsSuffix_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27917;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dorlandsSuffix_delta_old" ON "dbrdf_dorlandsSuffix_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dorlandsSuffix_delta_old" ON "dbrdf_dorlandsSuffix_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dorlandsSuffix_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1428
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_demolitionDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_demolitionDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27918;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_demolitionDate_delta_old" ON "dbrdf_demolitionDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_demolitionDate_delta_old" ON "dbrdf_demolitionDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_demolitionDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1429
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dateClosed_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dateClosed_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27919;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dateClosed_delta_old" ON "dbrdf_dateClosed_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dateClosed_delta_old" ON "dbrdf_dateClosed_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dateClosed_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1430
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_afiAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_afiAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27920;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_afiAward_delta_old" ON "dbrdf_afiAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_afiAward_delta_old" ON "dbrdf_afiAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_afiAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1431
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_chromosome_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_chromosome_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27921;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_chromosome_delta_old" ON "dbrdf_chromosome_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_chromosome_delta_old" ON "dbrdf_chromosome_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_chromosome_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1432
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_prospectTeam_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_prospectTeam_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27922;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_prospectTeam_delta_old" ON "dbrdf_prospectTeam_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_prospectTeam_delta_old" ON "dbrdf_prospectTeam_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_prospectTeam_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1433
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_arielAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_arielAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27923;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_arielAward_delta_old" ON "dbrdf_arielAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_arielAward_delta_old" ON "dbrdf_arielAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_arielAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1434
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastWin_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lastWin_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27924;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lastWin_delta_old" ON "dbrdf_lastWin_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lastWin_delta_old" ON "dbrdf_lastWin_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastWin_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1435
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_currentSeason_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_currentSeason_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27925;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_currentSeason_delta_old" ON "dbrdf_currentSeason_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_currentSeason_delta_old" ON "dbrdf_currentSeason_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_currentSeason_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1436
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_modelEndDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_modelEndDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27926;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_modelEndDate_delta_old" ON "dbrdf_modelEndDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_modelEndDate_delta_old" ON "dbrdf_modelEndDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_modelEndDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1437
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfStudioAlbums_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfStudioAlbums_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27927;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfStudioAlbums_delta_old" ON "dbrdf_numberOfStudioAlbums_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfStudioAlbums_delta_old" ON "dbrdf_numberOfStudioAlbums_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfStudioAlbums_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1438
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_viceLeaderParty_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_viceLeaderParty_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27928;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_viceLeaderParty_delta_old" ON "dbrdf_viceLeaderParty_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_viceLeaderParty_delta_old" ON "dbrdf_viceLeaderParty_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_viceLeaderParty_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1439
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfMunicipalities_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfMunicipalities_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27929;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfMunicipalities_delta_old" ON "dbrdf_numberOfMunicipalities_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfMunicipalities_delta_old" ON "dbrdf_numberOfMunicipalities_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfMunicipalities_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1440
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_maidenFlightRocket_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_maidenFlightRocket_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27930;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_maidenFlightRocket_delta_old" ON "dbrdf_maidenFlightRocket_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_maidenFlightRocket_delta_old" ON "dbrdf_maidenFlightRocket_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_maidenFlightRocket_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1441
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_characterInPlay_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_characterInPlay_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27931;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_characterInPlay_delta_old" ON "dbrdf_characterInPlay_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_characterInPlay_delta_old" ON "dbrdf_characterInPlay_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_characterInPlay_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1442
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_launchSite_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_launchSite_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27932;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_launchSite_delta_old" ON "dbrdf_launchSite_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_launchSite_delta_old" ON "dbrdf_launchSite_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_launchSite_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1443
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_emedicineSubject_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_emedicineSubject_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27933;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_emedicineSubject_delta_old" ON "dbrdf_emedicineSubject_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_emedicineSubject_delta_old" ON "dbrdf_emedicineSubject_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_emedicineSubject_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1444
    ---- DEPENDS ON: 1443, 1177, 1173, 1095, 1043, 754, 679, 164, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Disease>(?X) :- <http://dbpedia.org/ontology/icd9>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27934 FROM "__triples" t0 WHERE t0.p = 27659 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27934);
    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_Disease_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Disease_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27934;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Disease_delta_old" ON "dbrdf_Disease_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Disease_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/Disease$delta_new>(?Y) :- <http://dbpedia.org/ontology/Disease$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Disease_delta_new"(s) SELECT t1.o FROM "dbrdf_Disease_delta_old" t0, "__triples" t1 WHERE 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 = 27934);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1445
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_refseqmrna_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_refseqmrna_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27935;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_refseqmrna_delta_old" ON "dbrdf_refseqmrna_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_refseqmrna_delta_old" ON "dbrdf_refseqmrna_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_refseqmrna_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1446
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mass_delta_old2"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mass_delta_old2"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27936;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mass_delta_old2" ON "dbrdf_mass_delta_old2"(s, o); CREATE INDEX "IDX_1_dbrdf_mass_delta_old2" ON "dbrdf_mass_delta_old2"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mass_delta_new2"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1447
    ---- 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 = 27937;
    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 = 27937 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 = 27937 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftHelicopterObservation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftHelicopterObservation_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27938;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftHelicopterObservation_delta_old" ON "dbrdf_aircraftHelicopterObservation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftHelicopterObservation_delta_old" ON "dbrdf_aircraftHelicopterObservation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftHelicopterObservation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1449
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1450
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1451
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1452
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_startYearOfSales_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_startYearOfSales_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27942;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_startYearOfSales_delta_old" ON "dbrdf_startYearOfSales_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_startYearOfSales_delta_old" ON "dbrdf_startYearOfSales_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_startYearOfSales_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1453
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1454
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_viceLeader_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_viceLeader_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27944;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_viceLeader_delta_old" ON "dbrdf_viceLeader_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_viceLeader_delta_old" ON "dbrdf_viceLeader_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_viceLeader_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1455
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_hsvCoordinateSaturation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_hsvCoordinateSaturation_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27945;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_hsvCoordinateSaturation_delta_old" ON "dbrdf_hsvCoordinateSaturation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_hsvCoordinateSaturation_delta_old" ON "dbrdf_hsvCoordinateSaturation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_hsvCoordinateSaturation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1456
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftAttack_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftAttack_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27946;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftAttack_delta_old" ON "dbrdf_aircraftAttack_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftAttack_delta_old" ON "dbrdf_aircraftAttack_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftAttack_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1457
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfParticipatingAthletes_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfParticipatingAthletes_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27947;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfParticipatingAthletes_delta_old" ON "dbrdf_numberOfParticipatingAthletes_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfParticipatingAthletes_delta_old" ON "dbrdf_numberOfParticipatingAthletes_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfParticipatingAthletes_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1458
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourcePlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sourcePlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27948;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sourcePlace_delta_old" ON "dbrdf_sourcePlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sourcePlace_delta_old" ON "dbrdf_sourcePlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourcePlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1459
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_owningOrganisation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_owningOrganisation_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27949;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_owningOrganisation_delta_old" ON "dbrdf_owningOrganisation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_owningOrganisation_delta_old" ON "dbrdf_owningOrganisation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_owningOrganisation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1460
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dateOfAbandonment_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dateOfAbandonment_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27950;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dateOfAbandonment_delta_old" ON "dbrdf_dateOfAbandonment_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dateOfAbandonment_delta_old" ON "dbrdf_dateOfAbandonment_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dateOfAbandonment_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1461
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_broadcastNetwork_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_broadcastNetwork_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27951;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_broadcastNetwork_delta_old" ON "dbrdf_broadcastNetwork_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_broadcastNetwork_delta_old" ON "dbrdf_broadcastNetwork_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_broadcastNetwork_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1462
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfStateDeputies_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfStateDeputies_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27952;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfStateDeputies_delta_old" ON "dbrdf_numberOfStateDeputies_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfStateDeputies_delta_old" ON "dbrdf_numberOfStateDeputies_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfStateDeputies_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1463
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dateUse_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dateUse_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27953;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dateUse_delta_old" ON "dbrdf_dateUse_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dateUse_delta_old" ON "dbrdf_dateUse_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dateUse_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1464
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1465
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_capital_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_capital_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27955;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_capital_delta_old" ON "dbrdf_capital_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_capital_delta_old" ON "dbrdf_capital_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_capital_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1466
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_alumni_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_alumni_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27956;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_alumni_delta_old" ON "dbrdf_alumni_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_alumni_delta_old" ON "dbrdf_alumni_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_alumni_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1467
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dfE_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dfE_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27957;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dfE_delta_old" ON "dbrdf_dfE_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dfE_delta_old" ON "dbrdf_dfE_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dfE_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1468
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_issn_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_issn_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27958;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_issn_delta_old" ON "dbrdf_issn_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_issn_delta_old" ON "dbrdf_issn_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_issn_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1469
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_capitalRegion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_capitalRegion_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27959;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_capitalRegion_delta_old" ON "dbrdf_capitalRegion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_capitalRegion_delta_old" ON "dbrdf_capitalRegion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_capitalRegion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1470
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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