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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 132
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_apoapsis_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_apoapsis_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26614;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_apoapsis_delta_old" ON "dbrdf_apoapsis_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_apoapsis_delta_old" ON "dbrdf_apoapsis_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_apoapsis_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 133
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_brainInfoNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_brainInfoNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26615;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_brainInfoNumber_delta_old" ON "dbrdf_brainInfoNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_brainInfoNumber_delta_old" ON "dbrdf_brainInfoNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_brainInfoNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 134
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 135
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_pistonStroke_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_pistonStroke_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26617;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_pistonStroke_delta_old" ON "dbrdf_pistonStroke_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_pistonStroke_delta_old" ON "dbrdf_pistonStroke_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_pistonStroke_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 136
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_presenter_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_presenter_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26618;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_presenter_delta_old" ON "dbrdf_presenter_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_presenter_delta_old" ON "dbrdf_presenter_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_presenter_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 137
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_isoCodeRegion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_isoCodeRegion_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26619;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_isoCodeRegion_delta_old" ON "dbrdf_isoCodeRegion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_isoCodeRegion_delta_old" ON "dbrdf_isoCodeRegion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_isoCodeRegion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 138
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_house_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_house_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26620;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_house_delta_old" ON "dbrdf_house_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_house_delta_old" ON "dbrdf_house_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_house_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 139
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 140
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_governmentPlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_governmentPlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26622;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_governmentPlace_delta_old" ON "dbrdf_governmentPlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_governmentPlace_delta_old" ON "dbrdf_governmentPlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_governmentPlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 141
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_launchVehicle_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_launchVehicle_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26623;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_launchVehicle_delta_old" ON "dbrdf_launchVehicle_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_launchVehicle_delta_old" ON "dbrdf_launchVehicle_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_launchVehicle_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 142
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtKLPGA_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtKLPGA_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26624;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtKLPGA_delta_old" ON "dbrdf_winsAtKLPGA_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtKLPGA_delta_old" ON "dbrdf_winsAtKLPGA_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtKLPGA_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 143
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_portfolio_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_portfolio_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26625;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_portfolio_delta_old" ON "dbrdf_portfolio_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_portfolio_delta_old" ON "dbrdf_portfolio_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_portfolio_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 144
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_majorityFloorLeader_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_majorityFloorLeader_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26626;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_majorityFloorLeader_delta_old" ON "dbrdf_majorityFloorLeader_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_majorityFloorLeader_delta_old" ON "dbrdf_majorityFloorLeader_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_majorityFloorLeader_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 145
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_species_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_species_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26627;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_species_delta_old" ON "dbrdf_species_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_species_delta_old" ON "dbrdf_species_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_species_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 146
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sexualOrientation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sexualOrientation_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26628;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sexualOrientation_delta_old" ON "dbrdf_sexualOrientation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sexualOrientation_delta_old" ON "dbrdf_sexualOrientation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sexualOrientation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 147
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_revenue_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_revenue_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26629;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_revenue_delta_old" ON "dbrdf_revenue_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_revenue_delta_old" ON "dbrdf_revenue_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_revenue_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 148
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26630, t0.o FROM "dbrdf_populationDensity_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_populationDensity_delta_old0";
        INSERT INTO "dbrdf_populationDensity_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_populationDensity_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_populationDensity_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 149
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_apoapsis_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_apoapsis_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26631;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_apoapsis_delta_old0" ON "dbrdf_apoapsis_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_apoapsis_delta_old0" ON "dbrdf_apoapsis_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_apoapsis_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/apoapsis$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Spacecraft/apoapsis$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_apoapsis_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_apoapsis_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 = 26631 AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26631, t0.o FROM "dbrdf_apoapsis_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_apoapsis_delta_old0";
        INSERT INTO "dbrdf_apoapsis_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_apoapsis_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_apoapsis_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 150
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_notableIdea_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_notableIdea_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26632;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_notableIdea_delta_old" ON "dbrdf_notableIdea_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_notableIdea_delta_old" ON "dbrdf_notableIdea_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_notableIdea_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 151
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_networth_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_networth_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26633;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_networth_delta_old" ON "dbrdf_networth_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_networth_delta_old" ON "dbrdf_networth_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_networth_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 152
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_grayPage_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_grayPage_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26634;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_grayPage_delta_old" ON "dbrdf_grayPage_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_grayPage_delta_old" ON "dbrdf_grayPage_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_grayPage_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 153
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_pastMember_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_pastMember_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26635;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_pastMember_delta_old" ON "dbrdf_pastMember_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_pastMember_delta_old" ON "dbrdf_pastMember_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_pastMember_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 154
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_feastDay_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_feastDay_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26636;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_feastDay_delta_old" ON "dbrdf_feastDay_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_feastDay_delta_old" ON "dbrdf_feastDay_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_feastDay_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 155
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 156
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_partialFailedLaunches_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_partialFailedLaunches_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26638;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_partialFailedLaunches_delta_old" ON "dbrdf_partialFailedLaunches_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_partialFailedLaunches_delta_old" ON "dbrdf_partialFailedLaunches_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_partialFailedLaunches_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 157
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26639, t0.o FROM "dbrdf_density_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_density_delta_old1";
        INSERT INTO "dbrdf_density_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_density_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_density_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 158
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_callSign_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_callSign_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26640;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_callSign_delta_old" ON "dbrdf_callSign_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_callSign_delta_old" ON "dbrdf_callSign_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_callSign_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 159
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_iso6392Code_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_iso6392Code_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26641;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_iso6392Code_delta_old" ON "dbrdf_iso6392Code_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_iso6392Code_delta_old" ON "dbrdf_iso6392Code_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_iso6392Code_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 160
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_successfulLaunches_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_successfulLaunches_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26642;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_successfulLaunches_delta_old" ON "dbrdf_successfulLaunches_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_successfulLaunches_delta_old" ON "dbrdf_successfulLaunches_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_successfulLaunches_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 161
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_periapsis_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_periapsis_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26643;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_periapsis_delta_old" ON "dbrdf_periapsis_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_periapsis_delta_old" ON "dbrdf_periapsis_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_periapsis_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 162
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_closingYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_closingYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26644;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_closingYear_delta_old" ON "dbrdf_closingYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_closingYear_delta_old" ON "dbrdf_closingYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_closingYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 163
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_certificationDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_certificationDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26645;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_certificationDate_delta_old" ON "dbrdf_certificationDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_certificationDate_delta_old" ON "dbrdf_certificationDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_certificationDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 164
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_pdb_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_pdb_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26646;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_pdb_delta_old" ON "dbrdf_pdb_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_pdb_delta_old" ON "dbrdf_pdb_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_pdb_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 165
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_fees_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_fees_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26647;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_fees_delta_old" ON "dbrdf_fees_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_fees_delta_old" ON "dbrdf_fees_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_fees_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 166
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastFlightEndDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lastFlightEndDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26648;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lastFlightEndDate_delta_old" ON "dbrdf_lastFlightEndDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lastFlightEndDate_delta_old" ON "dbrdf_lastFlightEndDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastFlightEndDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 167
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtLPGA_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtLPGA_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26649;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtLPGA_delta_old" ON "dbrdf_winsAtLPGA_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtLPGA_delta_old" ON "dbrdf_winsAtLPGA_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtLPGA_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 168
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_volume_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_volume_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26650;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_volume_delta_old" ON "dbrdf_volume_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_volume_delta_old" ON "dbrdf_volume_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_volume_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 169
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_foundingYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_foundingYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26651;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_foundingYear_delta_old" ON "dbrdf_foundingYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_foundingYear_delta_old" ON "dbrdf_foundingYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_foundingYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 170
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_wikiPageRevisionID_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_wikiPageRevisionID_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26652;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_wikiPageRevisionID_delta_old" ON "dbrdf_wikiPageRevisionID_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_wikiPageRevisionID_delta_old" ON "dbrdf_wikiPageRevisionID_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_wikiPageRevisionID_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 171
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nameDay_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nameDay_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26653;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nameDay_delta_old" ON "dbrdf_nameDay_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nameDay_delta_old" ON "dbrdf_nameDay_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nameDay_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 172
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_humanDevelopmentIndex_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_humanDevelopmentIndex_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26654;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_humanDevelopmentIndex_delta_old" ON "dbrdf_humanDevelopmentIndex_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_humanDevelopmentIndex_delta_old" ON "dbrdf_humanDevelopmentIndex_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_humanDevelopmentIndex_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 173
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_fareZone_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_fareZone_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26655;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_fareZone_delta_old" ON "dbrdf_fareZone_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_fareZone_delta_old" ON "dbrdf_fareZone_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_fareZone_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 174
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_laurenceOlivierAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_laurenceOlivierAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26656;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_laurenceOlivierAward_delta_old" ON "dbrdf_laurenceOlivierAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_laurenceOlivierAward_delta_old" ON "dbrdf_laurenceOlivierAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_laurenceOlivierAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 175
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_terytCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_terytCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26657;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_terytCode_delta_old" ON "dbrdf_terytCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_terytCode_delta_old" ON "dbrdf_terytCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_terytCode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 176
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_iupacName_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_iupacName_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26658;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_iupacName_delta_old" ON "dbrdf_iupacName_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_iupacName_delta_old" ON "dbrdf_iupacName_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_iupacName_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 177
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_region_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_region_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26659;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_region_delta_old" ON "dbrdf_region_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_region_delta_old" ON "dbrdf_region_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_region_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 178
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_latestReleaseVersion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_latestReleaseVersion_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26660;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_latestReleaseVersion_delta_old" ON "dbrdf_latestReleaseVersion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_latestReleaseVersion_delta_old" ON "dbrdf_latestReleaseVersion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_latestReleaseVersion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 179
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_goalsInNationalTeam_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_goalsInNationalTeam_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26661;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_goalsInNationalTeam_delta_old" ON "dbrdf_goalsInNationalTeam_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_goalsInNationalTeam_delta_old" ON "dbrdf_goalsInNationalTeam_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_goalsInNationalTeam_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 180
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_premiereYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_premiereYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26662;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_premiereYear_delta_old" ON "dbrdf_premiereYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_premiereYear_delta_old" ON "dbrdf_premiereYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_premiereYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 181
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lowestPosition_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lowestPosition_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26663;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lowestPosition_delta_old" ON "dbrdf_lowestPosition_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lowestPosition_delta_old" ON "dbrdf_lowestPosition_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lowestPosition_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 182
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceDistrict_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sourceDistrict_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26664;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sourceDistrict_delta_old" ON "dbrdf_sourceDistrict_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sourceDistrict_delta_old" ON "dbrdf_sourceDistrict_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceDistrict_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 183
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_actScore_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_actScore_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26665;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_actScore_delta_old" ON "dbrdf_actScore_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_actScore_delta_old" ON "dbrdf_actScore_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_actScore_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 184
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_throwingSide_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_throwingSide_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26666;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_throwingSide_delta_old" ON "dbrdf_throwingSide_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_throwingSide_delta_old" ON "dbrdf_throwingSide_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_throwingSide_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 185
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 186
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ground_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ground_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26668;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ground_delta_old" ON "dbrdf_ground_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ground_delta_old" ON "dbrdf_ground_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ground_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 187
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nationalFilmAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nationalFilmAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26669;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nationalFilmAward_delta_old" ON "dbrdf_nationalFilmAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nationalFilmAward_delta_old" ON "dbrdf_nationalFilmAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nationalFilmAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 188
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_appointer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_appointer_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26670;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_appointer_delta_old" ON "dbrdf_appointer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_appointer_delta_old" ON "dbrdf_appointer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_appointer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 189
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mirDockings_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mirDockings_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26671;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mirDockings_delta_old" ON "dbrdf_mirDockings_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mirDockings_delta_old" ON "dbrdf_mirDockings_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mirDockings_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 190
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_requirement_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_requirement_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26672;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_requirement_delta_old" ON "dbrdf_requirement_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_requirement_delta_old" ON "dbrdf_requirement_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_requirement_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 191
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_originalName_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_originalName_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26673;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_originalName_delta_old" ON "dbrdf_originalName_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_originalName_delta_old" ON "dbrdf_originalName_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_originalName_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 192
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 193
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 194
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 195
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_commonName_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_commonName_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26677;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_commonName_delta_old" ON "dbrdf_commonName_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_commonName_delta_old" ON "dbrdf_commonName_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_commonName_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 196
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_port1_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_port1_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26678;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_port1_delta_old" ON "dbrdf_port1_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_port1_delta_old" ON "dbrdf_port1_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_port1_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 197
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_province_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_province_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26679;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_province_delta_old" ON "dbrdf_province_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_province_delta_old" ON "dbrdf_province_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_province_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 198
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_spokenIn_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_spokenIn_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26680;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_spokenIn_delta_old" ON "dbrdf_spokenIn_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_spokenIn_delta_old" ON "dbrdf_spokenIn_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_spokenIn_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 199
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_leftTributary_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_leftTributary_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26681;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_leftTributary_delta_old" ON "dbrdf_leftTributary_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_leftTributary_delta_old" ON "dbrdf_leftTributary_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_leftTributary_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 200
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_deputy_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_deputy_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26682;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_deputy_delta_old" ON "dbrdf_deputy_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_deputy_delta_old" ON "dbrdf_deputy_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_deputy_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 201
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_starring_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_starring_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26683;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_starring_delta_old" ON "dbrdf_starring_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_starring_delta_old" ON "dbrdf_starring_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_starring_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 202
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_equipment_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_equipment_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26684;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_equipment_delta_old" ON "dbrdf_equipment_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_equipment_delta_old" ON "dbrdf_equipment_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_equipment_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 203
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 204
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 205
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_symbol_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_symbol_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26687;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_symbol_delta_old" ON "dbrdf_symbol_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_symbol_delta_old" ON "dbrdf_symbol_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_symbol_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 206
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_height_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_height_delta_old1"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26688;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_height_delta_old1" ON "dbrdf_height_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_height_delta_old1" ON "dbrdf_height_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_height_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/Person/height$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Person/height$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_height_delta_new1"(s, o) SELECT t1.o, t0.o FROM "dbrdf_height_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 = 26688 AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26688, t0.o FROM "dbrdf_height_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_height_delta_old1";
        INSERT INTO "dbrdf_height_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_height_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_height_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 207
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_thirdCommander_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_thirdCommander_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26689;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_thirdCommander_delta_old" ON "dbrdf_thirdCommander_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_thirdCommander_delta_old" ON "dbrdf_thirdCommander_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_thirdCommander_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 208
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_humanDevelopmentIndexRankingCategory_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_humanDevelopmentIndexRankingCategory_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26690;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_humanDevelopmentIndexRankingCategory_delta_old" ON "dbrdf_humanDevelopmentIndexRankingCategory_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_humanDevelopmentIndexRankingCategory_delta_old" ON "dbrdf_humanDevelopmentIndexRankingCategory_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_humanDevelopmentIndexRankingCategory_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 209
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 210
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_garrison_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_garrison_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26692;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_garrison_delta_old" ON "dbrdf_garrison_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_garrison_delta_old" ON "dbrdf_garrison_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_garrison_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 211
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_chef_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_chef_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26693;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_chef_delta_old" ON "dbrdf_chef_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_chef_delta_old" ON "dbrdf_chef_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_chef_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 212
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_orderDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_orderDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26694;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_orderDate_delta_old" ON "dbrdf_orderDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_orderDate_delta_old" ON "dbrdf_orderDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_orderDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 213
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_targetSpaceStation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_targetSpaceStation_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26695;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_targetSpaceStation_delta_old" ON "dbrdf_targetSpaceStation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_targetSpaceStation_delta_old" ON "dbrdf_targetSpaceStation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_targetSpaceStation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 214
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_causalties_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_causalties_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26696;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_causalties_delta_old" ON "dbrdf_causalties_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_causalties_delta_old" ON "dbrdf_causalties_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_causalties_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 215
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_hsvCoordinateHue_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_hsvCoordinateHue_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26697;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_hsvCoordinateHue_delta_old" ON "dbrdf_hsvCoordinateHue_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_hsvCoordinateHue_delta_old" ON "dbrdf_hsvCoordinateHue_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_hsvCoordinateHue_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 216
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_narrator_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_narrator_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26698;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_narrator_delta_old" ON "dbrdf_narrator_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_narrator_delta_old" ON "dbrdf_narrator_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_narrator_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 217
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_commander_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_commander_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26699;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_commander_delta_old" ON "dbrdf_commander_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_commander_delta_old" ON "dbrdf_commander_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_commander_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 218
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 219
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_meanRadius_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_meanRadius_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26701;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_meanRadius_delta_old0" ON "dbrdf_meanRadius_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_meanRadius_delta_old0" ON "dbrdf_meanRadius_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_meanRadius_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26701, t0.o FROM "dbrdf_meanRadius_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_meanRadius_delta_old0";
        INSERT INTO "dbrdf_meanRadius_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_meanRadius_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_meanRadius_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 220
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_affiliation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_affiliation_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26702;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_affiliation_delta_old" ON "dbrdf_affiliation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_affiliation_delta_old" ON "dbrdf_affiliation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_affiliation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 221
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_simcCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_simcCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26703;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_simcCode_delta_old" ON "dbrdf_simcCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_simcCode_delta_old" ON "dbrdf_simcCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_simcCode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 222
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_birthPlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_birthPlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26704;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_birthPlace_delta_old" ON "dbrdf_birthPlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_birthPlace_delta_old" ON "dbrdf_birthPlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_birthPlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 223
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfDoctoralStudents_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfDoctoralStudents_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26705;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfDoctoralStudents_delta_old" ON "dbrdf_numberOfDoctoralStudents_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfDoctoralStudents_delta_old" ON "dbrdf_numberOfDoctoralStudents_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfDoctoralStudents_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 224
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_distanceToCapital_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_distanceToCapital_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26706;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_distanceToCapital_delta_old" ON "dbrdf_distanceToCapital_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_distanceToCapital_delta_old" ON "dbrdf_distanceToCapital_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_distanceToCapital_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 225
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_routeStart_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_routeStart_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26707;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_routeStart_delta_old" ON "dbrdf_routeStart_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_routeStart_delta_old" ON "dbrdf_routeStart_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_routeStart_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 226
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mass_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mass_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26708;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mass_delta_old" ON "dbrdf_mass_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mass_delta_old" ON "dbrdf_mass_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mass_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 227
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_explorer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_explorer_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26709;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_explorer_delta_old" ON "dbrdf_explorer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_explorer_delta_old" ON "dbrdf_explorer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_explorer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 228
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfSeasons_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfSeasons_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26710;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfSeasons_delta_old" ON "dbrdf_numberOfSeasons_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfSeasons_delta_old" ON "dbrdf_numberOfSeasons_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfSeasons_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 229
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_chancellor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_chancellor_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26711;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_chancellor_delta_old" ON "dbrdf_chancellor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_chancellor_delta_old" ON "dbrdf_chancellor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_chancellor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 230
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_noteOnRestingPlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_noteOnRestingPlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26712;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_noteOnRestingPlace_delta_old" ON "dbrdf_noteOnRestingPlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_noteOnRestingPlace_delta_old" ON "dbrdf_noteOnRestingPlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_noteOnRestingPlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 231
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_wingArea_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_wingArea_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26713;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_wingArea_delta_old" ON "dbrdf_wingArea_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_wingArea_delta_old" ON "dbrdf_wingArea_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_wingArea_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 232
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_orbitalPeriod_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_orbitalPeriod_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26714;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_orbitalPeriod_delta_old" ON "dbrdf_orbitalPeriod_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_orbitalPeriod_delta_old" ON "dbrdf_orbitalPeriod_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_orbitalPeriod_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 233
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaMetro_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_areaMetro_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26715;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_areaMetro_delta_old" ON "dbrdf_areaMetro_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_areaMetro_delta_old" ON "dbrdf_areaMetro_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaMetro_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 234
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_training_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_training_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26716;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_training_delta_old" ON "dbrdf_training_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_training_delta_old" ON "dbrdf_training_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_training_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 235
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_headteacher_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_headteacher_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26717;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_headteacher_delta_old" ON "dbrdf_headteacher_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_headteacher_delta_old" ON "dbrdf_headteacher_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_headteacher_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 236
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_creator_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_creator_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26718;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_creator_delta_old" ON "dbrdf_creator_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_creator_delta_old" ON "dbrdf_creator_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_creator_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 237
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_launchDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_launchDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26719;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_launchDate_delta_old" ON "dbrdf_launchDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_launchDate_delta_old" ON "dbrdf_launchDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_launchDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 238
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_stationVisitDuration_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_stationVisitDuration_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26720;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_stationVisitDuration_delta_old" ON "dbrdf_stationVisitDuration_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_stationVisitDuration_delta_old" ON "dbrdf_stationVisitDuration_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_stationVisitDuration_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 239
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_homeArena_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_homeArena_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26721;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_homeArena_delta_old" ON "dbrdf_homeArena_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_homeArena_delta_old" ON "dbrdf_homeArena_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_homeArena_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 240
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_assembly_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_assembly_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26722;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_assembly_delta_old" ON "dbrdf_assembly_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_assembly_delta_old" ON "dbrdf_assembly_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_assembly_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 241
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_meanRadius_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_meanRadius_delta_old1"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26723;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_meanRadius_delta_old1" ON "dbrdf_meanRadius_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_meanRadius_delta_old1" ON "dbrdf_meanRadius_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_meanRadius_delta_new1"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26723, t0.o FROM "dbrdf_meanRadius_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_meanRadius_delta_old1";
        INSERT INTO "dbrdf_meanRadius_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_meanRadius_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_meanRadius_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 242
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 243
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_artery_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_artery_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26725;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_artery_delta_old" ON "dbrdf_artery_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_artery_delta_old" ON "dbrdf_artery_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_artery_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 244
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_configuration_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_configuration_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26726;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_configuration_delta_old" ON "dbrdf_configuration_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_configuration_delta_old" ON "dbrdf_configuration_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_configuration_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 245
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_otherServingLines_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_otherServingLines_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26727;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_otherServingLines_delta_old" ON "dbrdf_otherServingLines_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_otherServingLines_delta_old" ON "dbrdf_otherServingLines_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_otherServingLines_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 246
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_poles_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_poles_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26728;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_poles_delta_old" ON "dbrdf_poles_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_poles_delta_old" ON "dbrdf_poles_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_poles_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 247
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastLaunch_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lastLaunch_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26729;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lastLaunch_delta_old" ON "dbrdf_lastLaunch_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lastLaunch_delta_old" ON "dbrdf_lastLaunch_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastLaunch_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 248
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_icaoLocationIdentifier_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_icaoLocationIdentifier_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26730;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_icaoLocationIdentifier_delta_old" ON "dbrdf_icaoLocationIdentifier_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_icaoLocationIdentifier_delta_old" ON "dbrdf_icaoLocationIdentifier_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_icaoLocationIdentifier_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 249
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_headLabel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_headLabel_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26731;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_headLabel_delta_old" ON "dbrdf_headLabel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_headLabel_delta_old" ON "dbrdf_headLabel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_headLabel_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 250
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_operatingSystem_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_operatingSystem_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26732;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_operatingSystem_delta_old" ON "dbrdf_operatingSystem_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_operatingSystem_delta_old" ON "dbrdf_operatingSystem_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_operatingSystem_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 251
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtSenEuro_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtSenEuro_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26733;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtSenEuro_delta_old" ON "dbrdf_winsAtSenEuro_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtSenEuro_delta_old" ON "dbrdf_winsAtSenEuro_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtSenEuro_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 252
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectType_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_projectType_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26734;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_projectType_delta_old" ON "dbrdf_projectType_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_projectType_delta_old" ON "dbrdf_projectType_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectType_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 253
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_postalCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_postalCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26735;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_postalCode_delta_old" ON "dbrdf_postalCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_postalCode_delta_old" ON "dbrdf_postalCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_postalCode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 254
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_poleDriverTeam_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_poleDriverTeam_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26736;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_poleDriverTeam_delta_old" ON "dbrdf_poleDriverTeam_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_poleDriverTeam_delta_old" ON "dbrdf_poleDriverTeam_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_poleDriverTeam_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 255
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_closed_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_closed_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26737;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_closed_delta_old" ON "dbrdf_closed_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_closed_delta_old" ON "dbrdf_closed_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_closed_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 256
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_religiousHead_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_religiousHead_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26738;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_religiousHead_delta_old" ON "dbrdf_religiousHead_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_religiousHead_delta_old" ON "dbrdf_religiousHead_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_religiousHead_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 257
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtChallenges_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtChallenges_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26739;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtChallenges_delta_old" ON "dbrdf_winsAtChallenges_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtChallenges_delta_old" ON "dbrdf_winsAtChallenges_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtChallenges_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 258
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 259
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ethnicity_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ethnicity_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26741;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ethnicity_delta_old" ON "dbrdf_ethnicity_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ethnicity_delta_old" ON "dbrdf_ethnicity_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ethnicity_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 260
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_minimumDischarge_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_minimumDischarge_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26742;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_minimumDischarge_delta_old" ON "dbrdf_minimumDischarge_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_minimumDischarge_delta_old" ON "dbrdf_minimumDischarge_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_minimumDischarge_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 261
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nobelLaureates_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nobelLaureates_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26743;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nobelLaureates_delta_old" ON "dbrdf_nobelLaureates_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nobelLaureates_delta_old" ON "dbrdf_nobelLaureates_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nobelLaureates_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 262
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_leaderName_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_leaderName_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26744;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_leaderName_delta_old" ON "dbrdf_leaderName_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_leaderName_delta_old" ON "dbrdf_leaderName_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_leaderName_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 263
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_iftaAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_iftaAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26745;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_iftaAward_delta_old" ON "dbrdf_iftaAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_iftaAward_delta_old" ON "dbrdf_iftaAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_iftaAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 264
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_longtype_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_longtype_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26746;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_longtype_delta_old" ON "dbrdf_longtype_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_longtype_delta_old" ON "dbrdf_longtype_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_longtype_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 265
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lccn_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lccn_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26747;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lccn_delta_old" ON "dbrdf_lccn_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lccn_delta_old" ON "dbrdf_lccn_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lccn_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 266
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsSection_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_alpsSection_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26748;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_alpsSection_delta_old" ON "dbrdf_alpsSection_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_alpsSection_delta_old" ON "dbrdf_alpsSection_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsSection_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 267
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 268
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_class_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_class_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26750;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_class_delta_old" ON "dbrdf_class_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_class_delta_old" ON "dbrdf_class_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_class_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 269
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sportDiscipline_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sportDiscipline_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26751;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sportDiscipline_delta_old" ON "dbrdf_sportDiscipline_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sportDiscipline_delta_old" ON "dbrdf_sportDiscipline_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sportDiscipline_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 270
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_trackNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_trackNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26752;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_trackNumber_delta_old" ON "dbrdf_trackNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_trackNumber_delta_old" ON "dbrdf_trackNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_trackNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 271
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_weight_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_weight_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26753;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_weight_delta_old0" ON "dbrdf_weight_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_weight_delta_old0" ON "dbrdf_weight_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_weight_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/Person/weight$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Person/weight$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_weight_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_weight_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 = 26753 AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26753, t0.o FROM "dbrdf_weight_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_weight_delta_old0";
        INSERT INTO "dbrdf_weight_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_weight_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_weight_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 272
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_registration_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_registration_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26754;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_registration_delta_old" ON "dbrdf_registration_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_registration_delta_old" ON "dbrdf_registration_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_registration_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 273
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_discharge_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_discharge_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26755;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_discharge_delta_old" ON "dbrdf_discharge_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_discharge_delta_old" ON "dbrdf_discharge_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_discharge_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 274
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_veneratedIn_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_veneratedIn_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26756;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_veneratedIn_delta_old" ON "dbrdf_veneratedIn_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_veneratedIn_delta_old" ON "dbrdf_veneratedIn_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_veneratedIn_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 275
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 276
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_flagBearer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_flagBearer_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26758;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_flagBearer_delta_old" ON "dbrdf_flagBearer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_flagBearer_delta_old" ON "dbrdf_flagBearer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_flagBearer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 277
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_frozen_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_frozen_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26759;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_frozen_delta_old" ON "dbrdf_frozen_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_frozen_delta_old" ON "dbrdf_frozen_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_frozen_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 278
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_engineType_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_engineType_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26760;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_engineType_delta_old" ON "dbrdf_engineType_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_engineType_delta_old" ON "dbrdf_engineType_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_engineType_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 279
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_building_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_building_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26761;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_building_delta_old" ON "dbrdf_building_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_building_delta_old" ON "dbrdf_building_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_building_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 280
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_temperature_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_temperature_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26762;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_temperature_delta_old" ON "dbrdf_temperature_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_temperature_delta_old" ON "dbrdf_temperature_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_temperature_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 281
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfMembers_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfMembers_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26763;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfMembers_delta_old" ON "dbrdf_numberOfMembers_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfMembers_delta_old" ON "dbrdf_numberOfMembers_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfMembers_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 282
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_boilingPoint_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_boilingPoint_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26764;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_boilingPoint_delta_old" ON "dbrdf_boilingPoint_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_boilingPoint_delta_old" ON "dbrdf_boilingPoint_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_boilingPoint_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 283
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstPopularVote_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstPopularVote_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26765;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstPopularVote_delta_old" ON "dbrdf_firstPopularVote_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstPopularVote_delta_old" ON "dbrdf_firstPopularVote_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstPopularVote_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 284
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_academyAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_academyAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26766;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_academyAward_delta_old" ON "dbrdf_academyAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_academyAward_delta_old" ON "dbrdf_academyAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_academyAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 285
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_timeInSpace_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_timeInSpace_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26767;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_timeInSpace_delta_old0" ON "dbrdf_timeInSpace_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_timeInSpace_delta_old0" ON "dbrdf_timeInSpace_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_timeInSpace_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/SpaceShuttle/timeInSpace$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/SpaceShuttle/timeInSpace$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_timeInSpace_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_timeInSpace_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 = 26767 AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26767, t0.o FROM "dbrdf_timeInSpace_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_timeInSpace_delta_old0";
        INSERT INTO "dbrdf_timeInSpace_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_timeInSpace_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_timeInSpace_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 286
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_co2Emission_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_co2Emission_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26768;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_co2Emission_delta_old0" ON "dbrdf_co2Emission_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_co2Emission_delta_old0" ON "dbrdf_co2Emission_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_co2Emission_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/AutomobileEngine/co2Emission$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/AutomobileEngine/co2Emission$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_co2Emission_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_co2Emission_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 = 26768 AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26768, t0.o FROM "dbrdf_co2Emission_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_co2Emission_delta_old0";
        INSERT INTO "dbrdf_co2Emission_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_co2Emission_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_co2Emission_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 287
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_secondTeam_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_secondTeam_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26769;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_secondTeam_delta_old" ON "dbrdf_secondTeam_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_secondTeam_delta_old" ON "dbrdf_secondTeam_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_secondTeam_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 288
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_percentageOfAreaWater_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_percentageOfAreaWater_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26770;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_percentageOfAreaWater_delta_old" ON "dbrdf_percentageOfAreaWater_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_percentageOfAreaWater_delta_old" ON "dbrdf_percentageOfAreaWater_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_percentageOfAreaWater_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 289
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_irishName_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_irishName_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26771;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_irishName_delta_old" ON "dbrdf_irishName_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_irishName_delta_old" ON "dbrdf_irishName_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_irishName_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 290
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_distanceToBelfast_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_distanceToBelfast_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26772;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_distanceToBelfast_delta_old" ON "dbrdf_distanceToBelfast_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_distanceToBelfast_delta_old" ON "dbrdf_distanceToBelfast_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_distanceToBelfast_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 291
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_computingInput_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_computingInput_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26773;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_computingInput_delta_old" ON "dbrdf_computingInput_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_computingInput_delta_old" ON "dbrdf_computingInput_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_computingInput_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 292
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 293
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_boilingPoint_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_boilingPoint_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26775;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_boilingPoint_delta_old0" ON "dbrdf_boilingPoint_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_boilingPoint_delta_old0" ON "dbrdf_boilingPoint_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_boilingPoint_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/ChemicalSubstance/boilingPoint$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/ChemicalSubstance/boilingPoint$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_boilingPoint_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_boilingPoint_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 = 26775 AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26775, t0.o FROM "dbrdf_boilingPoint_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_boilingPoint_delta_old0";
        INSERT INTO "dbrdf_boilingPoint_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_boilingPoint_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_boilingPoint_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 294
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerPartner_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_formerPartner_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26776;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_formerPartner_delta_old" ON "dbrdf_formerPartner_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_formerPartner_delta_old" ON "dbrdf_formerPartner_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerPartner_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 295
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_recordedIn_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_recordedIn_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26777;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_recordedIn_delta_old" ON "dbrdf_recordedIn_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_recordedIn_delta_old" ON "dbrdf_recordedIn_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_recordedIn_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 296
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 297
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_capitalMountain_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_capitalMountain_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26779;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_capitalMountain_delta_old" ON "dbrdf_capitalMountain_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_capitalMountain_delta_old" ON "dbrdf_capitalMountain_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_capitalMountain_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 298
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 299
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_currencyCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_currencyCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26781;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_currencyCode_delta_old" ON "dbrdf_currencyCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_currencyCode_delta_old" ON "dbrdf_currencyCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_currencyCode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 300
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_port2_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_port2_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26782;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_port2_delta_old" ON "dbrdf_port2_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_port2_delta_old" ON "dbrdf_port2_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_port2_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 301
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfEmployees_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfEmployees_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26783;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfEmployees_delta_old" ON "dbrdf_numberOfEmployees_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfEmployees_delta_old" ON "dbrdf_numberOfEmployees_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfEmployees_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 302
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_memberOfParliament_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_memberOfParliament_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26784;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_memberOfParliament_delta_old" ON "dbrdf_memberOfParliament_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_memberOfParliament_delta_old" ON "dbrdf_memberOfParliament_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_memberOfParliament_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26784, t0.o FROM "dbrdf_memberOfParliament_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
