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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 975
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_field_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_field_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27462;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_field_delta_old" ON "dbrdf_field_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_field_delta_old" ON "dbrdf_field_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_field_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 976
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 977
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_isPeerReviewed_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_isPeerReviewed_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27464;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_isPeerReviewed_delta_old" ON "dbrdf_isPeerReviewed_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_isPeerReviewed_delta_old" ON "dbrdf_isPeerReviewed_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_isPeerReviewed_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 978
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 979
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_associatedBand_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_associatedBand_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27466;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_associatedBand_delta_old" ON "dbrdf_associatedBand_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_associatedBand_delta_old" ON "dbrdf_associatedBand_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_associatedBand_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 980
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 981
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 982
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_educationSystem_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_educationSystem_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27469;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_educationSystem_delta_old" ON "dbrdf_educationSystem_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_educationSystem_delta_old" ON "dbrdf_educationSystem_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_educationSystem_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 983
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 984
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtChampionships_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtChampionships_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27471;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtChampionships_delta_old" ON "dbrdf_winsAtChampionships_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtChampionships_delta_old" ON "dbrdf_winsAtChampionships_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtChampionships_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 985
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 986
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 987
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_generalManager_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_generalManager_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27474;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_generalManager_delta_old" ON "dbrdf_generalManager_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_generalManager_delta_old" ON "dbrdf_generalManager_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_generalManager_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 988
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 989
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_formationYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_formationYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27476;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_formationYear_delta_old" ON "dbrdf_formationYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_formationYear_delta_old" ON "dbrdf_formationYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_formationYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_unloCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_unloCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27478;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_unloCode_delta_old" ON "dbrdf_unloCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_unloCode_delta_old" ON "dbrdf_unloCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_unloCode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 992
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lessPopulousCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lessPopulousCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27479;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lessPopulousCountry_delta_old" ON "dbrdf_lessPopulousCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lessPopulousCountry_delta_old" ON "dbrdf_lessPopulousCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lessPopulousCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 993
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 994
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 995
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 996
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 997
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_wingspan_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_wingspan_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27484;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_wingspan_delta_old" ON "dbrdf_wingspan_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_wingspan_delta_old" ON "dbrdf_wingspan_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_wingspan_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 998
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 999
    ---- DEPENDS ON: 603, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Theatre>(?X) :- <http://dbpedia.org/ontology/currentProduction>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27486 FROM "__triples" t0 WHERE t0.p = 27087 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27486);
    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_Theatre_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Theatre_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27486;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Theatre_delta_old" ON "dbrdf_Theatre_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Theatre_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/Theatre$delta_new>(?Y) :- <http://dbpedia.org/ontology/Theatre$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Theatre_delta_new"(s) SELECT t1.o FROM "dbrdf_Theatre_delta_old" t0, "__triples" t1 WHERE 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 = 27486);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1000
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1001
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_digitalSubChannel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_digitalSubChannel_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27488;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_digitalSubChannel_delta_old" ON "dbrdf_digitalSubChannel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_digitalSubChannel_delta_old" ON "dbrdf_digitalSubChannel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_digitalSubChannel_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1002
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1003
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1004
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_chairperson_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_chairperson_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27491;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_chairperson_delta_old" ON "dbrdf_chairperson_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_chairperson_delta_old" ON "dbrdf_chairperson_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_chairperson_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1005
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1006
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstPublicationDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstPublicationDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27493;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstPublicationDate_delta_old" ON "dbrdf_firstPublicationDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstPublicationDate_delta_old" ON "dbrdf_firstPublicationDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstPublicationDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1007
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1008
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1009
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_fuelType_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_fuelType_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27496;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_fuelType_delta_old" ON "dbrdf_fuelType_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_fuelType_delta_old" ON "dbrdf_fuelType_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_fuelType_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1010
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_infantMortality_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_infantMortality_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27497;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_infantMortality_delta_old" ON "dbrdf_infantMortality_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_infantMortality_delta_old" ON "dbrdf_infantMortality_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_infantMortality_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1011
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1012
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1013
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sisterCollege_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sisterCollege_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27500;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sisterCollege_delta_old" ON "dbrdf_sisterCollege_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sisterCollege_delta_old" ON "dbrdf_sisterCollege_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sisterCollege_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1014
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumDischarge_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_maximumDischarge_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27501;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_maximumDischarge_delta_old0" ON "dbrdf_maximumDischarge_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_maximumDischarge_delta_old0" ON "dbrdf_maximumDischarge_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumDischarge_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27501, t0.o FROM "dbrdf_maximumDischarge_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_maximumDischarge_delta_old0";
        INSERT INTO "dbrdf_maximumDischarge_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_maximumDischarge_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_maximumDischarge_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1015
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1016
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_product_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_product_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27503;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_product_delta_old" ON "dbrdf_product_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_product_delta_old" ON "dbrdf_product_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_product_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1017
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1018
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1019
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1020
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1021
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1022
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1023
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1024
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_isPartOfMilitaryConflict_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_isPartOfMilitaryConflict_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27511;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_isPartOfMilitaryConflict_delta_old" ON "dbrdf_isPartOfMilitaryConflict_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_isPartOfMilitaryConflict_delta_old" ON "dbrdf_isPartOfMilitaryConflict_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_isPartOfMilitaryConflict_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1025
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_leader_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_leader_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27512;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_leader_delta_old" ON "dbrdf_leader_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_leader_delta_old" ON "dbrdf_leader_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_leader_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1026
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_electionDateLeader_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_electionDateLeader_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27513;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_electionDateLeader_delta_old" ON "dbrdf_electionDateLeader_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_electionDateLeader_delta_old" ON "dbrdf_electionDateLeader_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_electionDateLeader_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1027
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1028
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1029
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1030
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_astrologicalSign_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_astrologicalSign_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27517;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_astrologicalSign_delta_old" ON "dbrdf_astrologicalSign_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_astrologicalSign_delta_old" ON "dbrdf_astrologicalSign_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_astrologicalSign_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1031
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_minorityLeader_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_minorityLeader_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27518;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_minorityLeader_delta_old" ON "dbrdf_minorityLeader_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_minorityLeader_delta_old" ON "dbrdf_minorityLeader_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_minorityLeader_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1032
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1033
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1034
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_heir_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_heir_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27521;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_heir_delta_old" ON "dbrdf_heir_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_heir_delta_old" ON "dbrdf_heir_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_heir_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1035
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_personName_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_personName_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27522;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_personName_delta_old" ON "dbrdf_personName_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_personName_delta_old" ON "dbrdf_personName_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_personName_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1036
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rocketStages_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rocketStages_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27523;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rocketStages_delta_old" ON "dbrdf_rocketStages_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rocketStages_delta_old" ON "dbrdf_rocketStages_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rocketStages_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1037
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstFlightStartDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstFlightStartDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27524;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstFlightStartDate_delta_old" ON "dbrdf_firstFlightStartDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstFlightStartDate_delta_old" ON "dbrdf_firstFlightStartDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstFlightStartDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1038
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_teamSize_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_teamSize_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27525;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_teamSize_delta_old" ON "dbrdf_teamSize_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_teamSize_delta_old" ON "dbrdf_teamSize_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_teamSize_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1039
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_egafdId_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_egafdId_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27526;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_egafdId_delta_old" ON "dbrdf_egafdId_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_egafdId_delta_old" ON "dbrdf_egafdId_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_egafdId_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1040
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_foundingDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_foundingDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27527;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_foundingDate_delta_old" ON "dbrdf_foundingDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_foundingDate_delta_old" ON "dbrdf_foundingDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_foundingDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1041
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_vicePrincipalLabel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_vicePrincipalLabel_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27528;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_vicePrincipalLabel_delta_old" ON "dbrdf_vicePrincipalLabel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_vicePrincipalLabel_delta_old" ON "dbrdf_vicePrincipalLabel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_vicePrincipalLabel_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1042
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ibdbId_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ibdbId_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27529;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ibdbId_delta_old" ON "dbrdf_ibdbId_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ibdbId_delta_old" ON "dbrdf_ibdbId_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ibdbId_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1043
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsSubgroup_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_alpsSubgroup_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27530;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_alpsSubgroup_delta_old" ON "dbrdf_alpsSubgroup_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_alpsSubgroup_delta_old" ON "dbrdf_alpsSubgroup_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsSubgroup_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1044
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_youthYears_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_youthYears_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27531;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_youthYears_delta_old" ON "dbrdf_youthYears_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_youthYears_delta_old" ON "dbrdf_youthYears_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_youthYears_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1045
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1046
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1047
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_welshName_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_welshName_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27534;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_welshName_delta_old" ON "dbrdf_welshName_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_welshName_delta_old" ON "dbrdf_welshName_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_welshName_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1048
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_capitalDistrict_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_capitalDistrict_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27535;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_capitalDistrict_delta_old" ON "dbrdf_capitalDistrict_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_capitalDistrict_delta_old" ON "dbrdf_capitalDistrict_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_capitalDistrict_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1049
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_graySubject_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_graySubject_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27536;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_graySubject_delta_old" ON "dbrdf_graySubject_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_graySubject_delta_old" ON "dbrdf_graySubject_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_graySubject_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1050
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_campusType_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_campusType_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27537;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_campusType_delta_old" ON "dbrdf_campusType_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_campusType_delta_old" ON "dbrdf_campusType_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_campusType_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1051
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_volume_delta_old3"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_volume_delta_old3"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27538;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_volume_delta_old3" ON "dbrdf_volume_delta_old3"(s, o); CREATE INDEX "IDX_1_dbrdf_volume_delta_old3" ON "dbrdf_volume_delta_old3"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_volume_delta_new3"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1052
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_address_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_address_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27539;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_address_delta_old" ON "dbrdf_address_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_address_delta_old" ON "dbrdf_address_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_address_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1053
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftTrainer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftTrainer_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27540;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftTrainer_delta_old" ON "dbrdf_aircraftTrainer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftTrainer_delta_old" ON "dbrdf_aircraftTrainer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftTrainer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27541, 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 1055
    ---- 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 = 27542;
    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 = 27542 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 = 27542 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_bodyStyle_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_bodyStyle_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27543;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_bodyStyle_delta_old" ON "dbrdf_bodyStyle_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_bodyStyle_delta_old" ON "dbrdf_bodyStyle_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_bodyStyle_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1057
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_peabodyAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_peabodyAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27544;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_peabodyAward_delta_old" ON "dbrdf_peabodyAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_peabodyAward_delta_old" ON "dbrdf_peabodyAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_peabodyAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1058
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaRural_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_areaRural_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27545;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_areaRural_delta_old" ON "dbrdf_areaRural_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_areaRural_delta_old" ON "dbrdf_areaRural_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaRural_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1059
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_stationVisitDuration_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_stationVisitDuration_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27546;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_stationVisitDuration_delta_old0" ON "dbrdf_stationVisitDuration_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_stationVisitDuration_delta_old0" ON "dbrdf_stationVisitDuration_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_stationVisitDuration_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27546, t0.o FROM "dbrdf_stationVisitDuration_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_stationVisitDuration_delta_old0";
        INSERT INTO "dbrdf_stationVisitDuration_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_stationVisitDuration_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_stationVisitDuration_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1060
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstWin_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstWin_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27547;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstWin_delta_old" ON "dbrdf_firstWin_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstWin_delta_old" ON "dbrdf_firstWin_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstWin_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1061
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_salary_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_salary_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27548;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_salary_delta_old" ON "dbrdf_salary_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_salary_delta_old" ON "dbrdf_salary_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_salary_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1062
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_pictureFormat_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_pictureFormat_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27549;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_pictureFormat_delta_old" ON "dbrdf_pictureFormat_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_pictureFormat_delta_old" ON "dbrdf_pictureFormat_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_pictureFormat_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1063
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_starRating_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_starRating_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27550;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_starRating_delta_old" ON "dbrdf_starRating_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_starRating_delta_old" ON "dbrdf_starRating_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_starRating_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1064
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_soocerLeaguePromoted_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_soocerLeaguePromoted_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27551;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_soocerLeaguePromoted_delta_old" ON "dbrdf_soocerLeaguePromoted_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_soocerLeaguePromoted_delta_old" ON "dbrdf_soocerLeaguePromoted_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_soocerLeaguePromoted_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1065
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_location_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_location_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27552;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_location_delta_old" ON "dbrdf_location_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_location_delta_old" ON "dbrdf_location_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_location_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1066
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_day_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_day_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27553;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_day_delta_old" ON "dbrdf_day_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_day_delta_old" ON "dbrdf_day_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_day_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1067
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nndbId_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nndbId_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27554;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nndbId_delta_old" ON "dbrdf_nndbId_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nndbId_delta_old" ON "dbrdf_nndbId_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nndbId_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1068
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfPostgraduateStudents_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfPostgraduateStudents_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27555;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfPostgraduateStudents_delta_old" ON "dbrdf_numberOfPostgraduateStudents_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfPostgraduateStudents_delta_old" ON "dbrdf_numberOfPostgraduateStudents_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfPostgraduateStudents_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1069
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1070
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_totalTravellers_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_totalTravellers_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27557;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_totalTravellers_delta_old" ON "dbrdf_totalTravellers_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_totalTravellers_delta_old" ON "dbrdf_totalTravellers_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_totalTravellers_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1071
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_uniprot_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_uniprot_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27558;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_uniprot_delta_old" ON "dbrdf_uniprot_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_uniprot_delta_old" ON "dbrdf_uniprot_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_uniprot_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1072
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1073
    ---- 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 = 27560;
    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/SpaceMission/lunarSurfaceTime$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/SpaceMission/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 = 27560 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/SpaceMission/lunarSurfaceTime$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/SpaceMission/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 = 27560 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceConfluenceRegion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sourceConfluenceRegion_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27561;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sourceConfluenceRegion_delta_old" ON "dbrdf_sourceConfluenceRegion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sourceConfluenceRegion_delta_old" ON "dbrdf_sourceConfluenceRegion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceConfluenceRegion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1075
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_broadcastTranslator_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_broadcastTranslator_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27562;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_broadcastTranslator_delta_old" ON "dbrdf_broadcastTranslator_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_broadcastTranslator_delta_old" ON "dbrdf_broadcastTranslator_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_broadcastTranslator_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1076
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_gameArtist_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_gameArtist_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27563;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_gameArtist_delta_old" ON "dbrdf_gameArtist_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_gameArtist_delta_old" ON "dbrdf_gameArtist_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_gameArtist_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1077
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1078
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27565, t0.o FROM "dbrdf_areaOfCatchment_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_areaOfCatchment_delta_old0";
        INSERT INTO "dbrdf_areaOfCatchment_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_areaOfCatchment_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_areaOfCatchment_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1079
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_otherParty_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_otherParty_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27566;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_otherParty_delta_old" ON "dbrdf_otherParty_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_otherParty_delta_old" ON "dbrdf_otherParty_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_otherParty_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1080
    ---- DEPENDS ON: 1079, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/OfficeHolder>(?X) :- <http://dbpedia.org/ontology/otherParty>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27567 FROM "__triples" t0 WHERE t0.p = 27566 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27567);
    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_OfficeHolder_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_OfficeHolder_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27567;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_OfficeHolder_delta_old" ON "dbrdf_OfficeHolder_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_OfficeHolder_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/OfficeHolder$delta_new>(?Y) :- <http://dbpedia.org/ontology/OfficeHolder$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_OfficeHolder_delta_new"(s) SELECT t1.o FROM "dbrdf_OfficeHolder_delta_old" t0, "__triples" t1 WHERE 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 = 27567);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1081
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_productionYears_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_productionYears_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27568;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_productionYears_delta_old" ON "dbrdf_productionYears_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_productionYears_delta_old" ON "dbrdf_productionYears_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_productionYears_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1082
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1083
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mouthDistrict_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mouthDistrict_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27570;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mouthDistrict_delta_old" ON "dbrdf_mouthDistrict_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mouthDistrict_delta_old" ON "dbrdf_mouthDistrict_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mouthDistrict_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1084
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_years_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_years_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27571;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_years_delta_old" ON "dbrdf_years_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_years_delta_old" ON "dbrdf_years_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_years_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1085
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1086
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1087
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_usedInWar_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_usedInWar_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27574;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_usedInWar_delta_old" ON "dbrdf_usedInWar_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_usedInWar_delta_old" ON "dbrdf_usedInWar_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_usedInWar_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1088
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_refseqprotein_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_refseqprotein_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27575;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_refseqprotein_delta_old" ON "dbrdf_refseqprotein_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_refseqprotein_delta_old" ON "dbrdf_refseqprotein_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_refseqprotein_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1089
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfAcademicStaff_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfAcademicStaff_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27576;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfAcademicStaff_delta_old" ON "dbrdf_numberOfAcademicStaff_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfAcademicStaff_delta_old" ON "dbrdf_numberOfAcademicStaff_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfAcademicStaff_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1090
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceConfluenceMountain_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sourceConfluenceMountain_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27577;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sourceConfluenceMountain_delta_old" ON "dbrdf_sourceConfluenceMountain_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sourceConfluenceMountain_delta_old" ON "dbrdf_sourceConfluenceMountain_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceConfluenceMountain_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1091
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_beltwayCity_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_beltwayCity_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27578;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_beltwayCity_delta_old" ON "dbrdf_beltwayCity_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_beltwayCity_delta_old" ON "dbrdf_beltwayCity_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_beltwayCity_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1092
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_river_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_river_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27579;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_river_delta_old" ON "dbrdf_river_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_river_delta_old" ON "dbrdf_river_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_river_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1093
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_deliveryDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_deliveryDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27580;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_deliveryDate_delta_old" ON "dbrdf_deliveryDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_deliveryDate_delta_old" ON "dbrdf_deliveryDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_deliveryDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1094
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_strength_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_strength_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27581;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_strength_delta_old" ON "dbrdf_strength_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_strength_delta_old" ON "dbrdf_strength_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_strength_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1095
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_christeningDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_christeningDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27582;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_christeningDate_delta_old" ON "dbrdf_christeningDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_christeningDate_delta_old" ON "dbrdf_christeningDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_christeningDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1096
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerCoach_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_formerCoach_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27583;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_formerCoach_delta_old" ON "dbrdf_formerCoach_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_formerCoach_delta_old" ON "dbrdf_formerCoach_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerCoach_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1097
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_debutTeam_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_debutTeam_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27584;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_debutTeam_delta_old" ON "dbrdf_debutTeam_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_debutTeam_delta_old" ON "dbrdf_debutTeam_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_debutTeam_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1098
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_criteria_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_criteria_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27585;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_criteria_delta_old" ON "dbrdf_criteria_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_criteria_delta_old" ON "dbrdf_criteria_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_criteria_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1099
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ratio_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ratio_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27586;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ratio_delta_old" ON "dbrdf_ratio_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ratio_delta_old" ON "dbrdf_ratio_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ratio_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1100
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_toll_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_toll_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27587;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_toll_delta_old" ON "dbrdf_toll_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_toll_delta_old" ON "dbrdf_toll_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_toll_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1101
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_languageCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_languageCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27588;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_languageCode_delta_old" ON "dbrdf_languageCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_languageCode_delta_old" ON "dbrdf_languageCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_languageCode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1102
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_origin_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_origin_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27589;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_origin_delta_old" ON "dbrdf_origin_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_origin_delta_old" ON "dbrdf_origin_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_origin_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1103
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_minimumInclination_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_minimumInclination_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27590;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_minimumInclination_delta_old" ON "dbrdf_minimumInclination_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_minimumInclination_delta_old" ON "dbrdf_minimumInclination_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_minimumInclination_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1104
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27591, t0.o FROM "dbrdf_weight_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_weight_delta_old1";
        INSERT INTO "dbrdf_weight_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_weight_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_weight_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1105
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1106
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nutsCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nutsCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27593;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nutsCode_delta_old" ON "dbrdf_nutsCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nutsCode_delta_old" ON "dbrdf_nutsCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nutsCode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1107
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_year_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_year_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27594;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_year_delta_old" ON "dbrdf_year_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_year_delta_old" ON "dbrdf_year_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_year_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1108
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_missions_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_missions_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27595;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_missions_delta_old" ON "dbrdf_missions_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_missions_delta_old" ON "dbrdf_missions_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_missions_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1109
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_landingVehicle_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_landingVehicle_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27596;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_landingVehicle_delta_old" ON "dbrdf_landingVehicle_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_landingVehicle_delta_old" ON "dbrdf_landingVehicle_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_landingVehicle_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1110
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_supplementalDraftYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_supplementalDraftYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27597;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_supplementalDraftYear_delta_old" ON "dbrdf_supplementalDraftYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_supplementalDraftYear_delta_old" ON "dbrdf_supplementalDraftYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_supplementalDraftYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1111
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastPosition_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lastPosition_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27598;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lastPosition_delta_old" ON "dbrdf_lastPosition_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lastPosition_delta_old" ON "dbrdf_lastPosition_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastPosition_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1112
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_openingFilm_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_openingFilm_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27599;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_openingFilm_delta_old" ON "dbrdf_openingFilm_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_openingFilm_delta_old" ON "dbrdf_openingFilm_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_openingFilm_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1113
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_commune_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_commune_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27600;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_commune_delta_old" ON "dbrdf_commune_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_commune_delta_old" ON "dbrdf_commune_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_commune_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1114
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_iso6391Code_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_iso6391Code_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27601;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_iso6391Code_delta_old" ON "dbrdf_iso6391Code_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_iso6391Code_delta_old" ON "dbrdf_iso6391Code_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_iso6391Code_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1115
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_perCapitaIncomeAsOf_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_perCapitaIncomeAsOf_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27602;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_perCapitaIncomeAsOf_delta_old" ON "dbrdf_perCapitaIncomeAsOf_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_perCapitaIncomeAsOf_delta_old" ON "dbrdf_perCapitaIncomeAsOf_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_perCapitaIncomeAsOf_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1116
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_suppreddedDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_suppreddedDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27603;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_suppreddedDate_delta_old" ON "dbrdf_suppreddedDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_suppreddedDate_delta_old" ON "dbrdf_suppreddedDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_suppreddedDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1117
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mapDescription_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mapDescription_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27604;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mapDescription_delta_old" ON "dbrdf_mapDescription_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mapDescription_delta_old" ON "dbrdf_mapDescription_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mapDescription_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1118
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_typeOfElectrification_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_typeOfElectrification_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27605;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_typeOfElectrification_delta_old" ON "dbrdf_typeOfElectrification_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_typeOfElectrification_delta_old" ON "dbrdf_typeOfElectrification_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_typeOfElectrification_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectBudgetTotal_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_projectBudgetTotal_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27607;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_projectBudgetTotal_delta_old" ON "dbrdf_projectBudgetTotal_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_projectBudgetTotal_delta_old" ON "dbrdf_projectBudgetTotal_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectBudgetTotal_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1121
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_department_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_department_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27608;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_department_delta_old" ON "dbrdf_department_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_department_delta_old" ON "dbrdf_department_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_department_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1122
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_routeJunction_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_routeJunction_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27609;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_routeJunction_delta_old" ON "dbrdf_routeJunction_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_routeJunction_delta_old" ON "dbrdf_routeJunction_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_routeJunction_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1123
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfStars_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfStars_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27610;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfStars_delta_old" ON "dbrdf_numberOfStars_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfStars_delta_old" ON "dbrdf_numberOfStars_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfStars_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1124
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_restingPlacePosition_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_restingPlacePosition_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27611;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_restingPlacePosition_delta_old" ON "dbrdf_restingPlacePosition_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_restingPlacePosition_delta_old" ON "dbrdf_restingPlacePosition_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_restingPlacePosition_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1125
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_amgid_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_amgid_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27612;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_amgid_delta_old" ON "dbrdf_amgid_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_amgid_delta_old" ON "dbrdf_amgid_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_amgid_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1126
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtOtherTournaments_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtOtherTournaments_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27613;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtOtherTournaments_delta_old" ON "dbrdf_winsAtOtherTournaments_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtOtherTournaments_delta_old" ON "dbrdf_winsAtOtherTournaments_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtOtherTournaments_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1127
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dateCompleted_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dateCompleted_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27614;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dateCompleted_delta_old" ON "dbrdf_dateCompleted_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dateCompleted_delta_old" ON "dbrdf_dateCompleted_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dateCompleted_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1128
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_subdivisions_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_subdivisions_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27615;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_subdivisions_delta_old" ON "dbrdf_subdivisions_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_subdivisions_delta_old" ON "dbrdf_subdivisions_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_subdivisions_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1129
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_recordDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_recordDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27616;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_recordDate_delta_old" ON "dbrdf_recordDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_recordDate_delta_old" ON "dbrdf_recordDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_recordDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1130
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_iataLocationIdentifier_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_iataLocationIdentifier_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27617;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_iataLocationIdentifier_delta_old" ON "dbrdf_iataLocationIdentifier_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_iataLocationIdentifier_delta_old" ON "dbrdf_iataLocationIdentifier_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_iataLocationIdentifier_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1131
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_buildingEndYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_buildingEndYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27618;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_buildingEndYear_delta_old" ON "dbrdf_buildingEndYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_buildingEndYear_delta_old" ON "dbrdf_buildingEndYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_buildingEndYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1132
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_deathPlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_deathPlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27619;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_deathPlace_delta_old" ON "dbrdf_deathPlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_deathPlace_delta_old" ON "dbrdf_deathPlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_deathPlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1133
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_visitorsTotal_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_visitorsTotal_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27620;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_visitorsTotal_delta_old" ON "dbrdf_visitorsTotal_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_visitorsTotal_delta_old" ON "dbrdf_visitorsTotal_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_visitorsTotal_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1134
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_parentOrganisation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_parentOrganisation_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27621;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_parentOrganisation_delta_old" ON "dbrdf_parentOrganisation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_parentOrganisation_delta_old" ON "dbrdf_parentOrganisation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_parentOrganisation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1135
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_notes_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_notes_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27622;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_notes_delta_old" ON "dbrdf_notes_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_notes_delta_old" ON "dbrdf_notes_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_notes_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1136
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_openingDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_openingDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27623;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_openingDate_delta_old" ON "dbrdf_openingDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_openingDate_delta_old" ON "dbrdf_openingDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_openingDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1137
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_beatifiedPlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_beatifiedPlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27624;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_beatifiedPlace_delta_old" ON "dbrdf_beatifiedPlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_beatifiedPlace_delta_old" ON "dbrdf_beatifiedPlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_beatifiedPlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1138
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_trustee_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_trustee_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27625;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_trustee_delta_old" ON "dbrdf_trustee_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_trustee_delta_old" ON "dbrdf_trustee_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_trustee_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1139
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1140
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_modelStartYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_modelStartYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27627;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_modelStartYear_delta_old" ON "dbrdf_modelStartYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_modelStartYear_delta_old" ON "dbrdf_modelStartYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_modelStartYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1141
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_internationally_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_internationally_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27628;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_internationally_delta_old" ON "dbrdf_internationally_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_internationally_delta_old" ON "dbrdf_internationally_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_internationally_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1142
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_editing_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_editing_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27629;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_editing_delta_old" ON "dbrdf_editing_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_editing_delta_old" ON "dbrdf_editing_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_editing_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1143
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_eTeatrId_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_eTeatrId_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_eTeatrId_delta_old" ON "dbrdf_eTeatrId_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_eTeatrId_delta_old" ON "dbrdf_eTeatrId_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_eTeatrId_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/eTeatrId$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/eTeatrId$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_eTeatrId_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_eTeatrId_delta_old" t0, "__triples" t1 WHERE 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/eTeatrId$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/eTeatrId$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
