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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_transmission_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_transmission_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27630;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_transmission_delta_old" ON "dbrdf_transmission_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_transmission_delta_old" ON "dbrdf_transmission_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_transmission_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1146
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_actingHeadteacher_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_actingHeadteacher_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27633;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_actingHeadteacher_delta_old" ON "dbrdf_actingHeadteacher_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_actingHeadteacher_delta_old" ON "dbrdf_actingHeadteacher_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_actingHeadteacher_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_shoeNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_shoeNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27636;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_shoeNumber_delta_old" ON "dbrdf_shoeNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_shoeNumber_delta_old" ON "dbrdf_shoeNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_shoeNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfRooms_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfRooms_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27637;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfRooms_delta_old" ON "dbrdf_numberOfRooms_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfRooms_delta_old" ON "dbrdf_numberOfRooms_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfRooms_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1155
    ---- DEPENDS ON: 1154, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mass_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mass_delta_old1"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27648;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mass_delta_old1" ON "dbrdf_mass_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_mass_delta_old1" ON "dbrdf_mass_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mass_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/Rocket/mass$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Rocket/mass$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_mass_delta_new1"(s, o) SELECT t1.o, t0.o FROM "dbrdf_mass_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 = 27648 AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27648, t0.o FROM "dbrdf_mass_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_mass_delta_old1";
        INSERT INTO "dbrdf_mass_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_mass_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_mass_delta_new1";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1165
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_creatorOfDish_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_creatorOfDish_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27652;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_creatorOfDish_delta_old" ON "dbrdf_creatorOfDish_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_creatorOfDish_delta_old" ON "dbrdf_creatorOfDish_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_creatorOfDish_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_undraftedYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_undraftedYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27654;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_undraftedYear_delta_old" ON "dbrdf_undraftedYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_undraftedYear_delta_old" ON "dbrdf_undraftedYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_undraftedYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1169
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_territory_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_territory_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27655;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_territory_delta_old" ON "dbrdf_territory_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_territory_delta_old" ON "dbrdf_territory_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_territory_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1171
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_governor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_governor_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27657;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_governor_delta_old" ON "dbrdf_governor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_governor_delta_old" ON "dbrdf_governor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_governor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_icd9_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_icd9_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27659;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_icd9_delta_old" ON "dbrdf_icd9_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_icd9_delta_old" ON "dbrdf_icd9_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_icd9_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_distributingCompany_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_distributingCompany_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27665;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_distributingCompany_delta_old" ON "dbrdf_distributingCompany_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_distributingCompany_delta_old" ON "dbrdf_distributingCompany_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_distributingCompany_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1182
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_currentTeamMember_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_currentTeamMember_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27671;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_currentTeamMember_delta_old" ON "dbrdf_currentTeamMember_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_currentTeamMember_delta_old" ON "dbrdf_currentTeamMember_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_currentTeamMember_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1186
    ---- DEPENDS ON: 1185, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27676, t0.o FROM "dbrdf_torqueOutput_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_torqueOutput_delta_old0";
        INSERT INTO "dbrdf_torqueOutput_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_torqueOutput_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_torqueOutput_delta_new0";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1197
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rival_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rival_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27686;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rival_delta_old" ON "dbrdf_rival_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rival_delta_old" ON "dbrdf_rival_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rival_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1201
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1204
    ---- DEPENDS ON: 1203, 955, 434, 431, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27695, t0.o FROM "dbrdf_lunarSurfaceTime_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_lunarSurfaceTime_delta_old0";
        INSERT INTO "dbrdf_lunarSurfaceTime_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lunarSurfaceTime_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_lunarSurfaceTime_delta_new0";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1225
    ---- DEPENDS ON: 864, 825, 21, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_AdministrativeRegion_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_AdministrativeRegion_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27711;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_AdministrativeRegion_delta_old" ON "dbrdf_AdministrativeRegion_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_AdministrativeRegion_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_AdministrativeArea_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_AdministrativeArea_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27712;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_AdministrativeArea_delta_old" ON "dbrdf_AdministrativeArea_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_AdministrativeArea_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/AdministrativeRegion$delta_new>(?X) :- <http://schema.org/AdministrativeArea$delta_old>(?X) .
        INSERT INTO "dbrdf_AdministrativeRegion_delta_new"(s) SELECT t0.s FROM "dbrdf_AdministrativeArea_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27711);


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


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


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


        -- Propagate $delta_new

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

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27722, t0.o FROM "dbrdf_dryCargo_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_dryCargo_delta_old0";
        INSERT INTO "dbrdf_dryCargo_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_dryCargo_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_dryCargo_delta_new0";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1237
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27730, t0.o FROM "dbrdf_cargoGas_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_cargoGas_delta_old0";
        INSERT INTO "dbrdf_cargoGas_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cargoGas_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_cargoGas_delta_new0";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1253
    ---- DEPENDS ON: 1252, 333, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_instrument_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_instrument_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27741;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_instrument_delta_old" ON "dbrdf_instrument_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_instrument_delta_old" ON "dbrdf_instrument_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_instrument_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1259
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aSide_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aSide_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27748;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aSide_delta_old" ON "dbrdf_aSide_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aSide_delta_old" ON "dbrdf_aSide_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aSide_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1264
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1267
    ---- DEPENDS ON: 1266, 454, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- <http://schema.org/Painting$delta_new>(?Y) :- <http://schema.org/Painting$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Painting_delta_new"(s) SELECT t1.o FROM "dbrdf_Painting_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 27754);


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


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


        -- Propagate $delta_new

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

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1273
    ---- DEPENDS ON: 1272, 1037, 902, 518, 255, 224, 210, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1274
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_grossDomesticProductAsOf_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_grossDomesticProductAsOf_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27763;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_grossDomesticProductAsOf_delta_old" ON "dbrdf_grossDomesticProductAsOf_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_grossDomesticProductAsOf_delta_old" ON "dbrdf_grossDomesticProductAsOf_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_grossDomesticProductAsOf_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Park_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Park_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27765;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Park_delta_old" ON "dbrdf_Park_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Park_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Park_delta_old0"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Park_delta_old0"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27766;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Park_delta_old0" ON "dbrdf_Park_delta_old0"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Park_delta_new0"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


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


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


        -- Propagate $delta_new

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

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1293
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1294
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Nonrecursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1300
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_SkiArea_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SkiArea_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27789;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SkiArea_delta_old" ON "dbrdf_SkiArea_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SkiArea_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SkiResort_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SkiResort_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27790;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SkiResort_delta_old" ON "dbrdf_SkiResort_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SkiResort_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


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


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


        -- Propagate $delta_new

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

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1301
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_largestCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_largestCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27791;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_largestCountry_delta_old" ON "dbrdf_largestCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_largestCountry_delta_old" ON "dbrdf_largestCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_largestCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1302
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1303
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1304
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1305
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- <http://dbpedia.org/ontology/capitalCountry$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/capitalCountry$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
