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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 835
    ---- 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 "dbrdf_isPartOfMilitaryConflict" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_isPartOfMilitaryConflict" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_isPartOfMilitaryConflict" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 837
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_chorusCharacterInPlay_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_chorusCharacterInPlay_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_chorusCharacterInPlay" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_chorusCharacterInPlay_delta_old" ON "dbrdf_chorusCharacterInPlay_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_chorusCharacterInPlay_delta_old" ON "dbrdf_chorusCharacterInPlay_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_chorusCharacterInPlay_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/chorusCharacterInPlay$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/chorusCharacterInPlay$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_chorusCharacterInPlay_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_chorusCharacterInPlay_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_chorusCharacterInPlay" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/chorusCharacterInPlay$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/chorusCharacterInPlay$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_chorusCharacterInPlay_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_chorusCharacterInPlay_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_chorusCharacterInPlay" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_chorusCharacterInPlay"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_chorusCharacterInPlay_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_chorusCharacterInPlay_delta_old";
        INSERT INTO "dbrdf_chorusCharacterInPlay_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_chorusCharacterInPlay_delta_new" t0;
        TRUNCATE TABLE "dbrdf_chorusCharacterInPlay_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 838
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 839
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 840
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_periapsis_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_periapsis_delta_old1"(s, o) SELECT t0.s, t0.o FROM "dbrdf_periapsis1" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_periapsis_delta_old1" ON "dbrdf_periapsis_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_periapsis_delta_old1" ON "dbrdf_periapsis_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_periapsis_delta_new1"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_periapsis1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_periapsis_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_periapsis_delta_old1";
        INSERT INTO "dbrdf_periapsis_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_periapsis_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_periapsis_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 841
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 842
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 843
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_poorestCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_poorestCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_poorestCountry" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_poorestCountry_delta_old" ON "dbrdf_poorestCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_poorestCountry_delta_old" ON "dbrdf_poorestCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_poorestCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/poorestCountry$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/poorestCountry$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_poorestCountry_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_poorestCountry_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_poorestCountry" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/poorestCountry$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/poorestCountry$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_poorestCountry_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_poorestCountry_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_poorestCountry" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_poorestCountry"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_poorestCountry_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_poorestCountry_delta_old";
        INSERT INTO "dbrdf_poorestCountry_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_poorestCountry_delta_new" t0;
        TRUNCATE TABLE "dbrdf_poorestCountry_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 844
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 845
    ---- 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 "dbrdf_peabodyAward" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_peabodyAward" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_peabodyAward" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_peabodyAward"(s, o) SELECT DISTINCT t0.s, 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 846
    ---- DEPENDS ON: 845, 463, 143, 57, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Comedian>(?X) :- <http://dbpedia.org/ontology/peabodyAward>(?X,?X1) .
    INSERT INTO "dbrdf_Comedian"(s) SELECT DISTINCT t0.s FROM "dbrdf_peabodyAward" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Comedian" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/Comedian>(?X) :- <http://dbpedia.org/ontology/americanComedyAward>(?X,?X1) .
    INSERT INTO "dbrdf_Comedian"(s) SELECT DISTINCT t0.s FROM "dbrdf_americanComedyAward" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Comedian" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/Comedian>(?X) :- <http://dbpedia.org/ontology/britishComedyAwards>(?X,?X1) .
    INSERT INTO "dbrdf_Comedian"(s) SELECT DISTINCT t0.s FROM "dbrdf_britishComedyAwards" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Comedian" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/Comedian>(?X) :- <http://dbpedia.org/ontology/olivierAward>(?X,?X1) .
    INSERT INTO "dbrdf_Comedian"(s) SELECT DISTINCT t0.s FROM "dbrdf_olivierAward" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Comedian" ex WHERE ex.s = t0.s);
    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_Comedian_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Comedian_delta_old"(s) SELECT t0.s FROM "dbrdf_Comedian" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Comedian_delta_old" ON "dbrdf_Comedian_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Comedian_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/Comedian$delta_new>(?Y) :- <http://dbpedia.org/ontology/Comedian$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Comedian_delta_new"(s) SELECT t1.o FROM "dbrdf_Comedian_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Comedian" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Comedian"(s) SELECT DISTINCT t0.s FROM "dbrdf_Comedian_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Comedian_delta_old";
        INSERT INTO "dbrdf_Comedian_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Comedian_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Comedian_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 847
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 848
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 849
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 850
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 851
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftHelicopterCargo_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftHelicopterCargo_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_aircraftHelicopterCargo" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftHelicopterCargo_delta_old" ON "dbrdf_aircraftHelicopterCargo_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftHelicopterCargo_delta_old" ON "dbrdf_aircraftHelicopterCargo_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftHelicopterCargo_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/aircraftHelicopterCargo$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/aircraftHelicopterCargo$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_aircraftHelicopterCargo_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_aircraftHelicopterCargo_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_aircraftHelicopterCargo" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/aircraftHelicopterCargo$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/aircraftHelicopterCargo$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_aircraftHelicopterCargo_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_aircraftHelicopterCargo_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_aircraftHelicopterCargo" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_aircraftHelicopterCargo"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_aircraftHelicopterCargo_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_aircraftHelicopterCargo_delta_old";
        INSERT INTO "dbrdf_aircraftHelicopterCargo_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_aircraftHelicopterCargo_delta_new" t0;
        TRUNCATE TABLE "dbrdf_aircraftHelicopterCargo_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 852
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_oclc_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_oclc_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_oclc" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_oclc_delta_old" ON "dbrdf_oclc_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_oclc_delta_old" ON "dbrdf_oclc_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_oclc_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/oclc$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/oclc$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_oclc_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_oclc_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_oclc" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/oclc$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/oclc$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_oclc_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_oclc_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_oclc" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_oclc"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_oclc_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_oclc_delta_old";
        INSERT INTO "dbrdf_oclc_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_oclc_delta_new" t0;
        TRUNCATE TABLE "dbrdf_oclc_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 853
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 854
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 855
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 856
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 857
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 858
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 859
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 860
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 861
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfCompetitors_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfCompetitors_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfCompetitors" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfCompetitors_delta_old" ON "dbrdf_numberOfCompetitors_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfCompetitors_delta_old" ON "dbrdf_numberOfCompetitors_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfCompetitors_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/numberOfCompetitors$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/numberOfCompetitors$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_numberOfCompetitors_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_numberOfCompetitors_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_numberOfCompetitors" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/numberOfCompetitors$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/numberOfCompetitors$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_numberOfCompetitors_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_numberOfCompetitors_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_numberOfCompetitors" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_numberOfCompetitors"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfCompetitors_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_numberOfCompetitors_delta_old";
        INSERT INTO "dbrdf_numberOfCompetitors_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfCompetitors_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfCompetitors_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 862
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_port2DockedTime_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_port2DockedTime_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_port2DockedTime0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_port2DockedTime_delta_old0" ON "dbrdf_port2DockedTime_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_port2DockedTime_delta_old0" ON "dbrdf_port2DockedTime_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_port2DockedTime_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_port2DockedTime0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_port2DockedTime_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_port2DockedTime_delta_old0";
        INSERT INTO "dbrdf_port2DockedTime_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_port2DockedTime_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_port2DockedTime_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 863
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_derivative_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_derivative_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_derivative" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_derivative_delta_old" ON "dbrdf_derivative_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_derivative_delta_old" ON "dbrdf_derivative_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_derivative_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/derivative$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/derivative$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_derivative_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_derivative_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_derivative" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/derivative$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/derivative$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_derivative_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_derivative_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_derivative" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_derivative"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_derivative_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_derivative_delta_old";
        INSERT INTO "dbrdf_derivative_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_derivative_delta_new" t0;
        TRUNCATE TABLE "dbrdf_derivative_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 864
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 865
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfCountries_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfCountries_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfCountries" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfCountries_delta_old" ON "dbrdf_numberOfCountries_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfCountries_delta_old" ON "dbrdf_numberOfCountries_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfCountries_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/numberOfCountries$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/numberOfCountries$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_numberOfCountries_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_numberOfCountries_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_numberOfCountries" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/numberOfCountries$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/numberOfCountries$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_numberOfCountries_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_numberOfCountries_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_numberOfCountries" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_numberOfCountries"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfCountries_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_numberOfCountries_delta_old";
        INSERT INTO "dbrdf_numberOfCountries_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfCountries_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfCountries_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 866
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_officialSchoolColour_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_officialSchoolColour_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_officialSchoolColour" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_officialSchoolColour_delta_old" ON "dbrdf_officialSchoolColour_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_officialSchoolColour_delta_old" ON "dbrdf_officialSchoolColour_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_officialSchoolColour_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/officialSchoolColour$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/officialSchoolColour$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_officialSchoolColour_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_officialSchoolColour_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_officialSchoolColour" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/officialSchoolColour$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/officialSchoolColour$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_officialSchoolColour_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_officialSchoolColour_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_officialSchoolColour" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_officialSchoolColour"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_officialSchoolColour_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_officialSchoolColour_delta_old";
        INSERT INTO "dbrdf_officialSchoolColour_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_officialSchoolColour_delta_new" t0;
        TRUNCATE TABLE "dbrdf_officialSchoolColour_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 867
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 868
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ComicBook_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ComicBook_delta_old"(s) SELECT t0.s FROM "dbrdf_ComicBook" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ComicBook_delta_old" ON "dbrdf_ComicBook_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ComicBook_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/ComicBook$delta_new>(?Y) :- <http://dbpedia.org/ontology/ComicBook$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_ComicBook_delta_new"(s) SELECT t1.o FROM "dbrdf_ComicBook_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_ComicBook" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_ComicBook"(s) SELECT DISTINCT t0.s FROM "dbrdf_ComicBook_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_ComicBook_delta_old";
        INSERT INTO "dbrdf_ComicBook_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_ComicBook_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ComicBook_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 869
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 870
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 871
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 872
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 873
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_MemberOfParliament_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_MemberOfParliament_delta_old"(s) SELECT t0.s FROM "dbrdf_MemberOfParliament" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_MemberOfParliament_delta_old" ON "dbrdf_MemberOfParliament_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_MemberOfParliament_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/MemberOfParliament$delta_new>(?Y) :- <http://dbpedia.org/ontology/MemberOfParliament$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_MemberOfParliament_delta_new"(s) SELECT t1.o FROM "dbrdf_MemberOfParliament_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_MemberOfParliament" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_MemberOfParliament"(s) SELECT DISTINCT t0.s FROM "dbrdf_MemberOfParliament_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_MemberOfParliament_delta_old";
        INSERT INTO "dbrdf_MemberOfParliament_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_MemberOfParliament_delta_new" t0;
        TRUNCATE TABLE "dbrdf_MemberOfParliament_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 874
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_RugbyClub_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_RugbyClub_delta_old"(s) SELECT t0.s FROM "dbrdf_RugbyClub" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_RugbyClub_delta_old" ON "dbrdf_RugbyClub_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_RugbyClub_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/RugbyClub$delta_new>(?Y) :- <http://dbpedia.org/ontology/RugbyClub$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_RugbyClub_delta_new"(s) SELECT t1.o FROM "dbrdf_RugbyClub_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_RugbyClub" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_RugbyClub"(s) SELECT DISTINCT t0.s FROM "dbrdf_RugbyClub_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_RugbyClub_delta_old";
        INSERT INTO "dbrdf_RugbyClub_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_RugbyClub_delta_new" t0;
        TRUNCATE TABLE "dbrdf_RugbyClub_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 875
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_height_delta_old3"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_height_delta_old3"(s, o) SELECT t0.s, t0.o FROM "dbrdf_height3" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_height_delta_old3" ON "dbrdf_height_delta_old3"(s, o); CREATE INDEX "IDX_1_dbrdf_height_delta_old3" ON "dbrdf_height_delta_old3"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_height_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/Person/height$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Person/height$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_height_delta_new3"(s, o) SELECT t1.o, t0.o FROM "dbrdf_height_delta_old3" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_height3" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/Person/height$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/Person/height$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_height_delta_new3"(s, o) SELECT t0.s, t1.o FROM "dbrdf_height_delta_old3" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_height3" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_height3"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_height_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_height_delta_old3";
        INSERT INTO "dbrdf_height_delta_old3"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_height_delta_new3" t0;
        TRUNCATE TABLE "dbrdf_height_delta_new3";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 876
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 877
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 878
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftHelicopterMultirole_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftHelicopterMultirole_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_aircraftHelicopterMultirole" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftHelicopterMultirole_delta_old" ON "dbrdf_aircraftHelicopterMultirole_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftHelicopterMultirole_delta_old" ON "dbrdf_aircraftHelicopterMultirole_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftHelicopterMultirole_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/aircraftHelicopterMultirole$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/aircraftHelicopterMultirole$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_aircraftHelicopterMultirole_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_aircraftHelicopterMultirole_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_aircraftHelicopterMultirole" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/aircraftHelicopterMultirole$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/aircraftHelicopterMultirole$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_aircraftHelicopterMultirole_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_aircraftHelicopterMultirole_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_aircraftHelicopterMultirole" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_aircraftHelicopterMultirole"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_aircraftHelicopterMultirole_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_aircraftHelicopterMultirole_delta_old";
        INSERT INTO "dbrdf_aircraftHelicopterMultirole_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_aircraftHelicopterMultirole_delta_new" t0;
        TRUNCATE TABLE "dbrdf_aircraftHelicopterMultirole_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 879
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Sculpture_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Sculpture_delta_old"(s) SELECT t0.s FROM "dbrdf_Sculpture" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Sculpture_delta_old" ON "dbrdf_Sculpture_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Sculpture_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Sculpture_delta_old0"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Sculpture_delta_old0"(s) SELECT t0.s FROM "dbrdf_Sculpture0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Sculpture_delta_old0" ON "dbrdf_Sculpture_delta_old0"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Sculpture_delta_new0"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://schema.org/Sculpture$delta_new>(?X) :- <http://dbpedia.org/ontology/Sculpture$delta_old>(?X) .
        INSERT INTO "dbrdf_Sculpture_delta_new"(s) SELECT t0.s FROM "dbrdf_Sculpture_delta_old0" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Sculpture" ex WHERE ex.s = t0.s);


        -- <http://schema.org/Sculpture$delta_new>(?Y) :- <http://schema.org/Sculpture$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Sculpture_delta_new"(s) SELECT t1.o FROM "dbrdf_Sculpture_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Sculpture" ex WHERE ex.s = t1.o);


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


        -- <http://dbpedia.org/ontology/Sculpture$delta_new>(?Y) :- <http://dbpedia.org/ontology/Sculpture$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Sculpture_delta_new0"(s) SELECT t1.o FROM "dbrdf_Sculpture_delta_old0" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Sculpture0" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Sculpture"(s) SELECT DISTINCT t0.s FROM "dbrdf_Sculpture_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Sculpture_delta_old";
        INSERT INTO "dbrdf_Sculpture_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Sculpture_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Sculpture_delta_new";

        INSERT INTO "dbrdf_Sculpture0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Sculpture_delta_new0" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Sculpture_delta_old0";
        INSERT INTO "dbrdf_Sculpture_delta_old0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Sculpture_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_Sculpture_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 880
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstAirDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstAirDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_firstAirDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstAirDate_delta_old" ON "dbrdf_firstAirDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstAirDate_delta_old" ON "dbrdf_firstAirDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstAirDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/firstAirDate$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/firstAirDate$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_firstAirDate_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_firstAirDate_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_firstAirDate" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/firstAirDate$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/firstAirDate$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_firstAirDate_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_firstAirDate_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_firstAirDate" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_firstAirDate"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_firstAirDate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_firstAirDate_delta_old";
        INSERT INTO "dbrdf_firstAirDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_firstAirDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_firstAirDate_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 881
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 882
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 883
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 884
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 885
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 886
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 887
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 888
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Galaxy/meanRadius$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Galaxy/meanRadius$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_meanRadius_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_meanRadius_delta_old0" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_meanRadius0" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/Galaxy/meanRadius$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/Galaxy/meanRadius$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_meanRadius_delta_new0"(s, o) SELECT t0.s, t1.o FROM "dbrdf_meanRadius_delta_old0" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_meanRadius0" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_meanRadius0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_meanRadius_delta_new0" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_meanRadius_delta_old0";
        INSERT INTO "dbrdf_meanRadius_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_meanRadius_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_meanRadius_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 889
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_recommissioningDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_recommissioningDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_recommissioningDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_recommissioningDate_delta_old" ON "dbrdf_recommissioningDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_recommissioningDate_delta_old" ON "dbrdf_recommissioningDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_recommissioningDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/recommissioningDate$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/recommissioningDate$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_recommissioningDate_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_recommissioningDate_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_recommissioningDate" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/recommissioningDate$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/recommissioningDate$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_recommissioningDate_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_recommissioningDate_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_recommissioningDate" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_recommissioningDate"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_recommissioningDate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_recommissioningDate_delta_old";
        INSERT INTO "dbrdf_recommissioningDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_recommissioningDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_recommissioningDate_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 890
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 891
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_routeEnd_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_routeEnd_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_routeEnd" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_routeEnd_delta_old" ON "dbrdf_routeEnd_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_routeEnd_delta_old" ON "dbrdf_routeEnd_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_routeEnd_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/routeEnd$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/routeEnd$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_routeEnd_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_routeEnd_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_routeEnd" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/routeEnd$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/routeEnd$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_routeEnd_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_routeEnd_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_routeEnd" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_routeEnd"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_routeEnd_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_routeEnd_delta_old";
        INSERT INTO "dbrdf_routeEnd_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_routeEnd_delta_new" t0;
        TRUNCATE TABLE "dbrdf_routeEnd_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 892
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 893
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_hasJunctionWith_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_hasJunctionWith_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_hasJunctionWith" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_hasJunctionWith_delta_old" ON "dbrdf_hasJunctionWith_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_hasJunctionWith_delta_old" ON "dbrdf_hasJunctionWith_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_hasJunctionWith_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/hasJunctionWith$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/hasJunctionWith$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_hasJunctionWith_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_hasJunctionWith_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_hasJunctionWith" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/hasJunctionWith$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/hasJunctionWith$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_hasJunctionWith_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_hasJunctionWith_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_hasJunctionWith" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_hasJunctionWith"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_hasJunctionWith_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_hasJunctionWith_delta_old";
        INSERT INTO "dbrdf_hasJunctionWith_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_hasJunctionWith_delta_new" t0;
        TRUNCATE TABLE "dbrdf_hasJunctionWith_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 894
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfCapitalDeputies_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfCapitalDeputies_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfCapitalDeputies" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfCapitalDeputies_delta_old" ON "dbrdf_numberOfCapitalDeputies_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfCapitalDeputies_delta_old" ON "dbrdf_numberOfCapitalDeputies_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfCapitalDeputies_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/numberOfCapitalDeputies$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/numberOfCapitalDeputies$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_numberOfCapitalDeputies_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_numberOfCapitalDeputies_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_numberOfCapitalDeputies" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/numberOfCapitalDeputies$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/numberOfCapitalDeputies$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_numberOfCapitalDeputies_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_numberOfCapitalDeputies_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_numberOfCapitalDeputies" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_numberOfCapitalDeputies"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfCapitalDeputies_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_numberOfCapitalDeputies_delta_old";
        INSERT INTO "dbrdf_numberOfCapitalDeputies_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfCapitalDeputies_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfCapitalDeputies_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 895
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 896
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 897
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_pastor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_pastor_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_pastor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_pastor_delta_old" ON "dbrdf_pastor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_pastor_delta_old" ON "dbrdf_pastor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_pastor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/pastor$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/pastor$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_pastor_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_pastor_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_pastor" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/pastor$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/pastor$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_pastor_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_pastor_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_pastor" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_pastor"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_pastor_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_pastor_delta_old";
        INSERT INTO "dbrdf_pastor_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_pastor_delta_new" t0;
        TRUNCATE TABLE "dbrdf_pastor_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 898
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_weddingParentsDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_weddingParentsDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_weddingParentsDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_weddingParentsDate_delta_old" ON "dbrdf_weddingParentsDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_weddingParentsDate_delta_old" ON "dbrdf_weddingParentsDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_weddingParentsDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/weddingParentsDate$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/weddingParentsDate$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_weddingParentsDate_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_weddingParentsDate_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_weddingParentsDate" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/weddingParentsDate$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/weddingParentsDate$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_weddingParentsDate_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_weddingParentsDate_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_weddingParentsDate" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_weddingParentsDate"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_weddingParentsDate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_weddingParentsDate_delta_old";
        INSERT INTO "dbrdf_weddingParentsDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_weddingParentsDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_weddingParentsDate_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 899
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_mass"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_mass_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_mass_delta_old";
        INSERT INTO "dbrdf_mass_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_mass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_mass_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 900
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 901
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectParticipant_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_projectParticipant_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_projectParticipant" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_projectParticipant_delta_old" ON "dbrdf_projectParticipant_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_projectParticipant_delta_old" ON "dbrdf_projectParticipant_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectParticipant_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/projectParticipant$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/projectParticipant$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_projectParticipant_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_projectParticipant_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_projectParticipant" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/projectParticipant$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/projectParticipant$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_projectParticipant_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_projectParticipant_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_projectParticipant" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_projectParticipant"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_projectParticipant_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_projectParticipant_delta_old";
        INSERT INTO "dbrdf_projectParticipant_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_projectParticipant_delta_new" t0;
        TRUNCATE TABLE "dbrdf_projectParticipant_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 902
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_bridgeCarries_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_bridgeCarries_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_bridgeCarries" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_bridgeCarries_delta_old" ON "dbrdf_bridgeCarries_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_bridgeCarries_delta_old" ON "dbrdf_bridgeCarries_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_bridgeCarries_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/bridgeCarries$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/bridgeCarries$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_bridgeCarries_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_bridgeCarries_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_bridgeCarries" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/bridgeCarries$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/bridgeCarries$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_bridgeCarries_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_bridgeCarries_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_bridgeCarries" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_bridgeCarries"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_bridgeCarries_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_bridgeCarries_delta_old";
        INSERT INTO "dbrdf_bridgeCarries_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_bridgeCarries_delta_new" t0;
        TRUNCATE TABLE "dbrdf_bridgeCarries_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 903
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 904
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 905
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_otherAppearances_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_otherAppearances_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_otherAppearances" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_otherAppearances_delta_old" ON "dbrdf_otherAppearances_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_otherAppearances_delta_old" ON "dbrdf_otherAppearances_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_otherAppearances_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/otherAppearances$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/otherAppearances$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_otherAppearances_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_otherAppearances_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_otherAppearances" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/otherAppearances$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/otherAppearances$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_otherAppearances_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_otherAppearances_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_otherAppearances" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_otherAppearances"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_otherAppearances_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_otherAppearances_delta_old";
        INSERT INTO "dbrdf_otherAppearances_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_otherAppearances_delta_new" t0;
        TRUNCATE TABLE "dbrdf_otherAppearances_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 906
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfCounties_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfCounties_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfCounties" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfCounties_delta_old" ON "dbrdf_numberOfCounties_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfCounties_delta_old" ON "dbrdf_numberOfCounties_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfCounties_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/numberOfCounties$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/numberOfCounties$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_numberOfCounties_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_numberOfCounties_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_numberOfCounties" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/numberOfCounties$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/numberOfCounties$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_numberOfCounties_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_numberOfCounties_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_numberOfCounties" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_numberOfCounties"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfCounties_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_numberOfCounties_delta_old";
        INSERT INTO "dbrdf_numberOfCounties_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfCounties_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfCounties_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 907
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_governmentMountain_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_governmentMountain_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_governmentMountain" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_governmentMountain_delta_old" ON "dbrdf_governmentMountain_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_governmentMountain_delta_old" ON "dbrdf_governmentMountain_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_governmentMountain_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/governmentMountain$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/governmentMountain$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_governmentMountain_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_governmentMountain_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_governmentMountain" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/governmentMountain$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/governmentMountain$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_governmentMountain_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_governmentMountain_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_governmentMountain" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_governmentMountain"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_governmentMountain_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_governmentMountain_delta_old";
        INSERT INTO "dbrdf_governmentMountain_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_governmentMountain_delta_new" t0;
        TRUNCATE TABLE "dbrdf_governmentMountain_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 908
    ---- 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 "dbrdf_infantMortality" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_infantMortality" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_infantMortality" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstRace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstRace_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_firstRace" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstRace_delta_old" ON "dbrdf_firstRace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstRace_delta_old" ON "dbrdf_firstRace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstRace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/firstRace$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/firstRace$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_firstRace_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_firstRace_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_firstRace" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/firstRace$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/firstRace$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_firstRace_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_firstRace_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_firstRace" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_firstRace"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_firstRace_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_firstRace_delta_old";
        INSERT INTO "dbrdf_firstRace_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_firstRace_delta_new" t0;
        TRUNCATE TABLE "dbrdf_firstRace_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 910
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_orbitalPeriod_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_orbitalPeriod_delta_old1"(s, o) SELECT t0.s, t0.o FROM "dbrdf_orbitalPeriod1" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_orbitalPeriod_delta_old1" ON "dbrdf_orbitalPeriod_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_orbitalPeriod_delta_old1" ON "dbrdf_orbitalPeriod_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_orbitalPeriod_delta_new1"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_orbitalPeriod1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_orbitalPeriod_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_orbitalPeriod_delta_old1";
        INSERT INTO "dbrdf_orbitalPeriod_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_orbitalPeriod_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_orbitalPeriod_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 911
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_areaMetro"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_areaMetro_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_areaMetro_delta_old";
        INSERT INTO "dbrdf_areaMetro_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_areaMetro_delta_new" t0;
        TRUNCATE TABLE "dbrdf_areaMetro_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 912
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 913
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 914
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaOfSearch_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_areaOfSearch_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_areaOfSearch" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_areaOfSearch_delta_old" ON "dbrdf_areaOfSearch_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_areaOfSearch_delta_old" ON "dbrdf_areaOfSearch_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaOfSearch_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/areaOfSearch$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/areaOfSearch$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_areaOfSearch_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_areaOfSearch_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_areaOfSearch" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/areaOfSearch$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/areaOfSearch$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_areaOfSearch_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_areaOfSearch_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_areaOfSearch" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_areaOfSearch"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_areaOfSearch_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_areaOfSearch_delta_old";
        INSERT INTO "dbrdf_areaOfSearch_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_areaOfSearch_delta_new" t0;
        TRUNCATE TABLE "dbrdf_areaOfSearch_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 915
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 916
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 917
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 918
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_bedCount_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_bedCount_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_bedCount" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_bedCount_delta_old" ON "dbrdf_bedCount_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_bedCount_delta_old" ON "dbrdf_bedCount_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_bedCount_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/bedCount$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/bedCount$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_bedCount_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_bedCount_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_bedCount" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/bedCount$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/bedCount$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_bedCount_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_bedCount_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_bedCount" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_bedCount"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_bedCount_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_bedCount_delta_old";
        INSERT INTO "dbrdf_bedCount_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_bedCount_delta_new" t0;
        TRUNCATE TABLE "dbrdf_bedCount_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 919
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 920
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Planet/meanRadius$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Planet/meanRadius$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_meanRadius_delta_new1"(s, o) SELECT t1.o, t0.o FROM "dbrdf_meanRadius_delta_old1" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_meanRadius1" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/Planet/meanRadius$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/Planet/meanRadius$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_meanRadius_delta_new1"(s, o) SELECT t0.s, t1.o FROM "dbrdf_meanRadius_delta_old1" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_meanRadius1" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_meanRadius1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_meanRadius_delta_new1" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_meanRadius_delta_old1";
        INSERT INTO "dbrdf_meanRadius_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_meanRadius_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_meanRadius_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 921
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_MixedMartialArtsEvent_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_MixedMartialArtsEvent_delta_old"(s) SELECT t0.s FROM "dbrdf_MixedMartialArtsEvent" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_MixedMartialArtsEvent_delta_old" ON "dbrdf_MixedMartialArtsEvent_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_MixedMartialArtsEvent_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/MixedMartialArtsEvent$delta_new>(?Y) :- <http://dbpedia.org/ontology/MixedMartialArtsEvent$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_MixedMartialArtsEvent_delta_new"(s) SELECT t1.o FROM "dbrdf_MixedMartialArtsEvent_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_MixedMartialArtsEvent" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_MixedMartialArtsEvent"(s) SELECT DISTINCT t0.s FROM "dbrdf_MixedMartialArtsEvent_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_MixedMartialArtsEvent_delta_old";
        INSERT INTO "dbrdf_MixedMartialArtsEvent_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_MixedMartialArtsEvent_delta_new" t0;
        TRUNCATE TABLE "dbrdf_MixedMartialArtsEvent_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 922
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 923
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 924
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_governmentElevation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_governmentElevation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_governmentElevation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_governmentElevation_delta_old" ON "dbrdf_governmentElevation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_governmentElevation_delta_old" ON "dbrdf_governmentElevation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_governmentElevation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/governmentElevation$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/governmentElevation$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_governmentElevation_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_governmentElevation_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_governmentElevation" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/governmentElevation$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/governmentElevation$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_governmentElevation_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_governmentElevation_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_governmentElevation" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_governmentElevation"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_governmentElevation_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_governmentElevation_delta_old";
        INSERT INTO "dbrdf_governmentElevation_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_governmentElevation_delta_new" t0;
        TRUNCATE TABLE "dbrdf_governmentElevation_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 925
    ---- 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 "dbrdf_openingFilm" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_openingFilm" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_openingFilm" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 927
    ---- 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 "dbrdf_lessPopulousCountry" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_lessPopulousCountry" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_lessPopulousCountry" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 929
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_equity_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_equity_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_equity" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_equity_delta_old" ON "dbrdf_equity_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_equity_delta_old" ON "dbrdf_equity_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_equity_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/equity$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/equity$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_equity_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_equity_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_equity" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/equity$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/equity$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_equity_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_equity_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_equity" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_equity"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_equity_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_equity_delta_old";
        INSERT INTO "dbrdf_equity_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_equity_delta_new" t0;
        TRUNCATE TABLE "dbrdf_equity_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 930
    ---- 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 "dbrdf_soocerLeaguePromoted" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_soocerLeaguePromoted" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_soocerLeaguePromoted" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 932
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 933
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 934
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_GovernmentAgency_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_GovernmentAgency_delta_old"(s) SELECT t0.s FROM "dbrdf_GovernmentAgency" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_GovernmentAgency_delta_old" ON "dbrdf_GovernmentAgency_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_GovernmentAgency_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_GovernmentOrganization_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_GovernmentOrganization_delta_old"(s) SELECT t0.s FROM "dbrdf_GovernmentOrganization" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_GovernmentOrganization_delta_old" ON "dbrdf_GovernmentOrganization_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_GovernmentOrganization_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/GovernmentAgency$delta_new>(?X) :- <http://schema.org/GovernmentOrganization$delta_old>(?X) .
        INSERT INTO "dbrdf_GovernmentAgency_delta_new"(s) SELECT t0.s FROM "dbrdf_GovernmentOrganization_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_GovernmentAgency" ex WHERE ex.s = t0.s);


        -- <http://dbpedia.org/ontology/GovernmentAgency$delta_new>(?Y) :- <http://dbpedia.org/ontology/GovernmentAgency$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_GovernmentAgency_delta_new"(s) SELECT t1.o FROM "dbrdf_GovernmentAgency_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_GovernmentAgency" ex WHERE ex.s = t1.o);


        -- <http://schema.org/GovernmentOrganization$delta_new>(?X) :- <http://dbpedia.org/ontology/GovernmentAgency$delta_old>(?X) .
        INSERT INTO "dbrdf_GovernmentOrganization_delta_new"(s) SELECT t0.s FROM "dbrdf_GovernmentAgency_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_GovernmentOrganization" ex WHERE ex.s = t0.s);


        -- <http://schema.org/GovernmentOrganization$delta_new>(?Y) :- <http://schema.org/GovernmentOrganization$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_GovernmentOrganization_delta_new"(s) SELECT t1.o FROM "dbrdf_GovernmentOrganization_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_GovernmentOrganization" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_GovernmentAgency"(s) SELECT DISTINCT t0.s FROM "dbrdf_GovernmentAgency_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_GovernmentAgency_delta_old";
        INSERT INTO "dbrdf_GovernmentAgency_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_GovernmentAgency_delta_new" t0;
        TRUNCATE TABLE "dbrdf_GovernmentAgency_delta_new";

        INSERT INTO "dbrdf_GovernmentOrganization"(s) SELECT DISTINCT t0.s FROM "dbrdf_GovernmentOrganization_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_GovernmentOrganization_delta_old";
        INSERT INTO "dbrdf_GovernmentOrganization_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_GovernmentOrganization_delta_new" t0;
        TRUNCATE TABLE "dbrdf_GovernmentOrganization_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 935
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 936
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_principalArea_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_principalArea_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_principalArea" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_principalArea_delta_old" ON "dbrdf_principalArea_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_principalArea_delta_old" ON "dbrdf_principalArea_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_principalArea_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/principalArea$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/principalArea$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_principalArea_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_principalArea_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_principalArea" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/principalArea$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/principalArea$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_principalArea_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_principalArea_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_principalArea" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_principalArea"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_principalArea_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_principalArea_delta_old";
        INSERT INTO "dbrdf_principalArea_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_principalArea_delta_new" t0;
        TRUNCATE TABLE "dbrdf_principalArea_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 937
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_finalPublicationDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_finalPublicationDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_finalPublicationDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_finalPublicationDate_delta_old" ON "dbrdf_finalPublicationDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_finalPublicationDate_delta_old" ON "dbrdf_finalPublicationDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_finalPublicationDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/finalPublicationDate$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/finalPublicationDate$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_finalPublicationDate_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_finalPublicationDate_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_finalPublicationDate" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/finalPublicationDate$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/finalPublicationDate$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_finalPublicationDate_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_finalPublicationDate_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_finalPublicationDate" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_finalPublicationDate"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_finalPublicationDate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_finalPublicationDate_delta_old";
        INSERT INTO "dbrdf_finalPublicationDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_finalPublicationDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_finalPublicationDate_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 938
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_minimumDischarge_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_minimumDischarge_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_minimumDischarge0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_minimumDischarge_delta_old0" ON "dbrdf_minimumDischarge_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_minimumDischarge_delta_old0" ON "dbrdf_minimumDischarge_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_minimumDischarge_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/minimumDischarge$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Stream/minimumDischarge$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_minimumDischarge_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_minimumDischarge_delta_old0" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_minimumDischarge0" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_minimumDischarge0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_minimumDischarge_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_minimumDischarge_delta_old0";
        INSERT INTO "dbrdf_minimumDischarge_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_minimumDischarge_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_minimumDischarge_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 939
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 940
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_riverBranchOf_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_riverBranchOf_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_riverBranchOf" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_riverBranchOf_delta_old" ON "dbrdf_riverBranchOf_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_riverBranchOf_delta_old" ON "dbrdf_riverBranchOf_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_riverBranchOf_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/riverBranchOf$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/riverBranchOf$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_riverBranchOf_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_riverBranchOf_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_riverBranchOf" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/riverBranchOf$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/riverBranchOf$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_riverBranchOf_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_riverBranchOf_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_riverBranchOf" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_riverBranchOf"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_riverBranchOf_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_riverBranchOf_delta_old";
        INSERT INTO "dbrdf_riverBranchOf_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_riverBranchOf_delta_new" t0;
        TRUNCATE TABLE "dbrdf_riverBranchOf_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 941
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 942
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 943
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 944
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_HumanGene_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_HumanGene_delta_old"(s) SELECT t0.s FROM "dbrdf_HumanGene" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_HumanGene_delta_old" ON "dbrdf_HumanGene_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_HumanGene_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/HumanGene$delta_new>(?Y) :- <http://dbpedia.org/ontology/HumanGene$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_HumanGene_delta_new"(s) SELECT t1.o FROM "dbrdf_HumanGene_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_HumanGene" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_HumanGene"(s) SELECT DISTINCT t0.s FROM "dbrdf_HumanGene_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_HumanGene_delta_old";
        INSERT INTO "dbrdf_HumanGene_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_HumanGene_delta_new" t0;
        TRUNCATE TABLE "dbrdf_HumanGene_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 945
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 946
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_gaudiAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_gaudiAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_gaudiAward" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_gaudiAward_delta_old" ON "dbrdf_gaudiAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_gaudiAward_delta_old" ON "dbrdf_gaudiAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_gaudiAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/gaudiAward$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/gaudiAward$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_gaudiAward_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_gaudiAward_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_gaudiAward" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/gaudiAward$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/gaudiAward$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_gaudiAward_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_gaudiAward_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_gaudiAward" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_gaudiAward"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_gaudiAward_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_gaudiAward_delta_old";
        INSERT INTO "dbrdf_gaudiAward_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_gaudiAward_delta_new" t0;
        TRUNCATE TABLE "dbrdf_gaudiAward_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 947
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_discharge_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_discharge_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_discharge0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_discharge_delta_old0" ON "dbrdf_discharge_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_discharge_delta_old0" ON "dbrdf_discharge_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_discharge_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/discharge$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/discharge$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_discharge_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_discharge_delta_old0" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_discharge0" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_discharge0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_discharge_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_discharge_delta_old0";
        INSERT INTO "dbrdf_discharge_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_discharge_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_discharge_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 948
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 949
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_VicePrimeMinister_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_VicePrimeMinister_delta_old"(s) SELECT t0.s FROM "dbrdf_VicePrimeMinister" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_VicePrimeMinister_delta_old" ON "dbrdf_VicePrimeMinister_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_VicePrimeMinister_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/VicePrimeMinister$delta_new>(?Y) :- <http://dbpedia.org/ontology/VicePrimeMinister$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_VicePrimeMinister_delta_new"(s) SELECT t1.o FROM "dbrdf_VicePrimeMinister_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_VicePrimeMinister" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_VicePrimeMinister"(s) SELECT DISTINCT t0.s FROM "dbrdf_VicePrimeMinister_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_VicePrimeMinister_delta_old";
        INSERT INTO "dbrdf_VicePrimeMinister_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_VicePrimeMinister_delta_new" t0;
        TRUNCATE TABLE "dbrdf_VicePrimeMinister_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 950
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 951
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 952
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumDepth_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_maximumDepth_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_maximumDepth" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_maximumDepth_delta_old" ON "dbrdf_maximumDepth_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_maximumDepth_delta_old" ON "dbrdf_maximumDepth_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumDepth_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/maximumDepth$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/maximumDepth$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_maximumDepth_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_maximumDepth_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_maximumDepth" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/maximumDepth$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/maximumDepth$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_maximumDepth_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_maximumDepth_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_maximumDepth" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_maximumDepth"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_maximumDepth_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_maximumDepth_delta_old";
        INSERT INTO "dbrdf_maximumDepth_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_maximumDepth_delta_new" t0;
        TRUNCATE TABLE "dbrdf_maximumDepth_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 953
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberBuilt_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberBuilt_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberBuilt" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberBuilt_delta_old" ON "dbrdf_numberBuilt_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberBuilt_delta_old" ON "dbrdf_numberBuilt_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberBuilt_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/numberBuilt$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/numberBuilt$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_numberBuilt_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_numberBuilt_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_numberBuilt" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/numberBuilt$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/numberBuilt$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_numberBuilt_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_numberBuilt_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_numberBuilt" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_numberBuilt"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberBuilt_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_numberBuilt_delta_old";
        INSERT INTO "dbrdf_numberBuilt_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberBuilt_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberBuilt_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 954
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 955
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_raceLength_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_raceLength_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_raceLength" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_raceLength_delta_old" ON "dbrdf_raceLength_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_raceLength_delta_old" ON "dbrdf_raceLength_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_raceLength_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/raceLength$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/raceLength$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_raceLength_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_raceLength_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_raceLength" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/raceLength$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/raceLength$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_raceLength_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_raceLength_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_raceLength" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_raceLength"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_raceLength_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_raceLength_delta_old";
        INSERT INTO "dbrdf_raceLength_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_raceLength_delta_new" t0;
        TRUNCATE TABLE "dbrdf_raceLength_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 956
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_temperature_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_temperature_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_temperature0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_temperature_delta_old0" ON "dbrdf_temperature_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_temperature_delta_old0" ON "dbrdf_temperature_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_temperature_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/Planet/temperature$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Planet/temperature$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_temperature_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_temperature_delta_old0" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_temperature0" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_temperature0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_temperature_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_temperature_delta_old0";
        INSERT INTO "dbrdf_temperature_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_temperature_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_temperature_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 957
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_largestMetro_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_largestMetro_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_largestMetro" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_largestMetro_delta_old" ON "dbrdf_largestMetro_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_largestMetro_delta_old" ON "dbrdf_largestMetro_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_largestMetro_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/largestMetro$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/largestMetro$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_largestMetro_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_largestMetro_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_largestMetro" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/largestMetro$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/largestMetro$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_largestMetro_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_largestMetro_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_largestMetro" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_largestMetro"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_largestMetro_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_largestMetro_delta_old";
        INSERT INTO "dbrdf_largestMetro_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_largestMetro_delta_new" t0;
        TRUNCATE TABLE "dbrdf_largestMetro_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 958
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 959
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_boilingPoint_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_boilingPoint_delta_old1"(s, o) SELECT t0.s, t0.o FROM "dbrdf_boilingPoint1" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_boilingPoint_delta_old1" ON "dbrdf_boilingPoint_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_boilingPoint_delta_old1" ON "dbrdf_boilingPoint_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_boilingPoint_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/boilingPoint$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/boilingPoint$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_boilingPoint_delta_new1"(s, o) SELECT t1.o, t0.o FROM "dbrdf_boilingPoint_delta_old1" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_boilingPoint1" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_boilingPoint1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_boilingPoint_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_boilingPoint_delta_old1";
        INSERT INTO "dbrdf_boilingPoint_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_boilingPoint_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_boilingPoint_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 960
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftHelicopterUtility_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftHelicopterUtility_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_aircraftHelicopterUtility" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftHelicopterUtility_delta_old" ON "dbrdf_aircraftHelicopterUtility_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftHelicopterUtility_delta_old" ON "dbrdf_aircraftHelicopterUtility_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftHelicopterUtility_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/aircraftHelicopterUtility$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/aircraftHelicopterUtility$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_aircraftHelicopterUtility_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_aircraftHelicopterUtility_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_aircraftHelicopterUtility" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/aircraftHelicopterUtility$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/aircraftHelicopterUtility$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_aircraftHelicopterUtility_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_aircraftHelicopterUtility_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_aircraftHelicopterUtility" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_aircraftHelicopterUtility"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_aircraftHelicopterUtility_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_aircraftHelicopterUtility_delta_old";
        INSERT INTO "dbrdf_aircraftHelicopterUtility_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_aircraftHelicopterUtility_delta_new" t0;
        TRUNCATE TABLE "dbrdf_aircraftHelicopterUtility_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 961
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_originalStartPoint_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_originalStartPoint_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_originalStartPoint" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_originalStartPoint_delta_old" ON "dbrdf_originalStartPoint_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_originalStartPoint_delta_old" ON "dbrdf_originalStartPoint_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_originalStartPoint_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/originalStartPoint$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/originalStartPoint$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_originalStartPoint_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_originalStartPoint_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_originalStartPoint" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/originalStartPoint$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/originalStartPoint$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_originalStartPoint_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_originalStartPoint_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_originalStartPoint" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_originalStartPoint"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_originalStartPoint_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_originalStartPoint_delta_old";
        INSERT INTO "dbrdf_originalStartPoint_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_originalStartPoint_delta_new" t0;
        TRUNCATE TABLE "dbrdf_originalStartPoint_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 962
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cargoFuel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cargoFuel_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_cargoFuel" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cargoFuel_delta_old" ON "dbrdf_cargoFuel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_cargoFuel_delta_old" ON "dbrdf_cargoFuel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cargoFuel_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/cargoFuel$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/cargoFuel$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_cargoFuel_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_cargoFuel_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_cargoFuel" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/cargoFuel$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/cargoFuel$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_cargoFuel_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_cargoFuel_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_cargoFuel" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_cargoFuel"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cargoFuel_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_cargoFuel_delta_old";
        INSERT INTO "dbrdf_cargoFuel_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cargoFuel_delta_new" t0;
        TRUNCATE TABLE "dbrdf_cargoFuel_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 963
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 964
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 965
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 966
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 967
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_totalMass_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_totalMass_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_totalMass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_totalMass_delta_old" ON "dbrdf_totalMass_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_totalMass_delta_old" ON "dbrdf_totalMass_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_totalMass_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 968
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 969
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 970
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 971
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Year_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Year_delta_old"(s) SELECT t0.s FROM "dbrdf_Year" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Year_delta_old" ON "dbrdf_Year_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Year_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Year$delta_new>(?Y) :- <http://dbpedia.org/ontology/Year$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Year_delta_new"(s) SELECT t1.o FROM "dbrdf_Year_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Year" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Year"(s) SELECT DISTINCT t0.s FROM "dbrdf_Year_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Year_delta_old";
        INSERT INTO "dbrdf_Year_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Year_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Year_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 972
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 973
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfFederalDeputies_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfFederalDeputies_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfFederalDeputies" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfFederalDeputies_delta_old" ON "dbrdf_numberOfFederalDeputies_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfFederalDeputies_delta_old" ON "dbrdf_numberOfFederalDeputies_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfFederalDeputies_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/numberOfFederalDeputies$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/numberOfFederalDeputies$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_numberOfFederalDeputies_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_numberOfFederalDeputies_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_numberOfFederalDeputies" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/numberOfFederalDeputies$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/numberOfFederalDeputies$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_numberOfFederalDeputies_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_numberOfFederalDeputies_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_numberOfFederalDeputies" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_numberOfFederalDeputies"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfFederalDeputies_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_numberOfFederalDeputies_delta_old";
        INSERT INTO "dbrdf_numberOfFederalDeputies_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfFederalDeputies_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfFederalDeputies_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 974
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_endYearOfInsertion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_endYearOfInsertion_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_endYearOfInsertion" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_endYearOfInsertion_delta_old" ON "dbrdf_endYearOfInsertion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_endYearOfInsertion_delta_old" ON "dbrdf_endYearOfInsertion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_endYearOfInsertion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/endYearOfInsertion$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/endYearOfInsertion$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_endYearOfInsertion_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_endYearOfInsertion_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_endYearOfInsertion" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/endYearOfInsertion$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/endYearOfInsertion$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_endYearOfInsertion_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_endYearOfInsertion_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_endYearOfInsertion" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_endYearOfInsertion"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_endYearOfInsertion_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_endYearOfInsertion_delta_old";
        INSERT INTO "dbrdf_endYearOfInsertion_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_endYearOfInsertion_delta_new" t0;
        TRUNCATE TABLE "dbrdf_endYearOfInsertion_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_numberOfEmployees_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfEmployees_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfEmployees" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfEmployees_delta_old" ON "dbrdf_numberOfEmployees_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfEmployees_delta_old" ON "dbrdf_numberOfEmployees_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfEmployees_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/numberOfEmployees$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/numberOfEmployees$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_numberOfEmployees_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_numberOfEmployees_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_numberOfEmployees" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/numberOfEmployees$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/numberOfEmployees$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_numberOfEmployees_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_numberOfEmployees_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_numberOfEmployees" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_numberOfEmployees"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfEmployees_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_numberOfEmployees_delta_old";
        INSERT INTO "dbrdf_numberOfEmployees_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfEmployees_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfEmployees_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_memberOfParliament_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_memberOfParliament_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_memberOfParliament" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_memberOfParliament_delta_old" ON "dbrdf_memberOfParliament_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_memberOfParliament_delta_old" ON "dbrdf_memberOfParliament_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_memberOfParliament_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/memberOfParliament$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/memberOfParliament$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_memberOfParliament_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_memberOfParliament_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_memberOfParliament" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/memberOfParliament$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/memberOfParliament$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_memberOfParliament_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_memberOfParliament_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_memberOfParliament" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_memberOfParliament"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_memberOfParliament_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_memberOfParliament_delta_old";
        INSERT INTO "dbrdf_memberOfParliament_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_memberOfParliament_delta_new" t0;
        TRUNCATE TABLE "dbrdf_memberOfParliament_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_meanTemperature_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_meanTemperature_delta_old1"(s, o) SELECT t0.s, t0.o FROM "dbrdf_meanTemperature1" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_meanTemperature_delta_old1" ON "dbrdf_meanTemperature_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_meanTemperature_delta_old1" ON "dbrdf_meanTemperature_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_meanTemperature_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/meanTemperature$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/meanTemperature$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_meanTemperature_delta_new1"(s, o) SELECT t1.o, t0.o FROM "dbrdf_meanTemperature_delta_old1" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_meanTemperature1" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/meanTemperature$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/meanTemperature$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_meanTemperature_delta_new1"(s, o) SELECT t0.s, t1.o FROM "dbrdf_meanTemperature_delta_old1" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_meanTemperature1" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_meanTemperature1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_meanTemperature_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_meanTemperature_delta_old1";
        INSERT INTO "dbrdf_meanTemperature_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_meanTemperature_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_meanTemperature_delta_new1";

    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_portrayer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_portrayer_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_portrayer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_portrayer_delta_old" ON "dbrdf_portrayer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_portrayer_delta_old" ON "dbrdf_portrayer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_portrayer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/portrayer$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/portrayer$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_portrayer_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_portrayer_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_portrayer" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/portrayer$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/portrayer$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_portrayer_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_portrayer_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_portrayer" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_portrayer"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_portrayer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_portrayer_delta_old";
        INSERT INTO "dbrdf_portrayer_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_portrayer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_portrayer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 979
    ---- DEPENDS ON: 978, 475, 58, 19, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/FictionalCharacter>(?X) :- <http://dbpedia.org/ontology/portrayer>(?X,?X1) .
    INSERT INTO "dbrdf_FictionalCharacter"(s) SELECT DISTINCT t0.s FROM "dbrdf_portrayer" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_FictionalCharacter" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/FictionalCharacter>(?X) :- <http://dbpedia.org/ontology/firstAppearance>(?X,?X1) .
    INSERT INTO "dbrdf_FictionalCharacter"(s) SELECT DISTINCT t0.s FROM "dbrdf_firstAppearance" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_FictionalCharacter" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/FictionalCharacter>(?X) :- <http://dbpedia.org/ontology/ComicsCharacter>(?X) .
    INSERT INTO "dbrdf_FictionalCharacter"(s) SELECT t0.s FROM "dbrdf_ComicsCharacter" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_FictionalCharacter" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/FictionalCharacter>(?X) :- <http://dbpedia.org/ontology/lastAppearance>(?X,?X1) .
    INSERT INTO "dbrdf_FictionalCharacter"(s) SELECT DISTINCT t0.s FROM "dbrdf_lastAppearance" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_FictionalCharacter" ex WHERE ex.s = t0.s);
    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_FictionalCharacter_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_FictionalCharacter_delta_old"(s) SELECT t0.s FROM "dbrdf_FictionalCharacter" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_FictionalCharacter_delta_old" ON "dbrdf_FictionalCharacter_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_FictionalCharacter_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/FictionalCharacter$delta_new>(?Y) :- <http://dbpedia.org/ontology/FictionalCharacter$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_FictionalCharacter_delta_new"(s) SELECT t1.o FROM "dbrdf_FictionalCharacter_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_FictionalCharacter" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_FictionalCharacter"(s) SELECT DISTINCT t0.s FROM "dbrdf_FictionalCharacter_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_FictionalCharacter_delta_old";
        INSERT INTO "dbrdf_FictionalCharacter_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_FictionalCharacter_delta_new" t0;
        TRUNCATE TABLE "dbrdf_FictionalCharacter_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_coolingSystem_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_coolingSystem_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_coolingSystem" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_coolingSystem_delta_old" ON "dbrdf_coolingSystem_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_coolingSystem_delta_old" ON "dbrdf_coolingSystem_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_coolingSystem_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/coolingSystem$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/coolingSystem$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_coolingSystem_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_coolingSystem_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_coolingSystem" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/coolingSystem$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/coolingSystem$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_coolingSystem_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_coolingSystem_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_coolingSystem" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_coolingSystem"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_coolingSystem_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_coolingSystem_delta_old";
        INSERT INTO "dbrdf_coolingSystem_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_coolingSystem_delta_new" t0;
        TRUNCATE TABLE "dbrdf_coolingSystem_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_definition_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_definition_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_definition" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_definition_delta_old" ON "dbrdf_definition_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_definition_delta_old" ON "dbrdf_definition_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_definition_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/definition$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/definition$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_definition_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_definition_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_definition" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/definition$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/definition$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_definition_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_definition_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_definition" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_definition"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_definition_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_definition_delta_old";
        INSERT INTO "dbrdf_definition_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_definition_delta_new" t0;
        TRUNCATE TABLE "dbrdf_definition_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_managementCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_managementCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_managementCountry" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_managementCountry_delta_old" ON "dbrdf_managementCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_managementCountry_delta_old" ON "dbrdf_managementCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_managementCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/managementCountry$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/managementCountry$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_managementCountry_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_managementCountry_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_managementCountry" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/managementCountry$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/managementCountry$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_managementCountry_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_managementCountry_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_managementCountry" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_managementCountry"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_managementCountry_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_managementCountry_delta_old";
        INSERT INTO "dbrdf_managementCountry_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_managementCountry_delta_new" t0;
        TRUNCATE TABLE "dbrdf_managementCountry_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_countryOrigin_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_countryOrigin_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_countryOrigin" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_countryOrigin_delta_old" ON "dbrdf_countryOrigin_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_countryOrigin_delta_old" ON "dbrdf_countryOrigin_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_countryOrigin_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/countryOrigin$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/countryOrigin$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_countryOrigin_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_countryOrigin_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_countryOrigin" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/countryOrigin$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/countryOrigin$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_countryOrigin_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_countryOrigin_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_countryOrigin" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_countryOrigin"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_countryOrigin_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_countryOrigin_delta_old";
        INSERT INTO "dbrdf_countryOrigin_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_countryOrigin_delta_new" t0;
        TRUNCATE TABLE "dbrdf_countryOrigin_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_duration_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_duration_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_duration" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_duration_delta_old" ON "dbrdf_duration_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_duration_delta_old" ON "dbrdf_duration_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_duration_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/duration$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/duration$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_duration_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_duration_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_duration" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/duration$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/duration$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_duration_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_duration_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_duration" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_duration"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_duration_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_duration_delta_old";
        INSERT INTO "dbrdf_duration_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_duration_delta_new" t0;
        TRUNCATE TABLE "dbrdf_duration_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_productionCompany_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_productionCompany_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_productionCompany" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_productionCompany_delta_old" ON "dbrdf_productionCompany_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_productionCompany_delta_old" ON "dbrdf_productionCompany_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_productionCompany_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/productionCompany$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/productionCompany$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_productionCompany_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_productionCompany_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_productionCompany" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/productionCompany$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/productionCompany$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_productionCompany_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_productionCompany_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_productionCompany" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_productionCompany"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_productionCompany_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_productionCompany_delta_old";
        INSERT INTO "dbrdf_productionCompany_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_productionCompany_delta_new" t0;
        TRUNCATE TABLE "dbrdf_productionCompany_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_entrezgene_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_entrezgene_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_entrezgene" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_entrezgene_delta_old" ON "dbrdf_entrezgene_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_entrezgene_delta_old" ON "dbrdf_entrezgene_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_entrezgene_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/entrezgene$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/entrezgene$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_entrezgene_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_entrezgene_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_entrezgene" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/entrezgene$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/entrezgene$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_entrezgene_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_entrezgene_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_entrezgene" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_entrezgene"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_entrezgene_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_entrezgene_delta_old";
        INSERT INTO "dbrdf_entrezgene_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_entrezgene_delta_new" t0;
        TRUNCATE TABLE "dbrdf_entrezgene_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_Congressman_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Congressman_delta_old"(s) SELECT t0.s FROM "dbrdf_Congressman" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Congressman_delta_old" ON "dbrdf_Congressman_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Congressman_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/Congressman$delta_new>(?Y) :- <http://dbpedia.org/ontology/Congressman$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Congressman_delta_new"(s) SELECT t1.o FROM "dbrdf_Congressman_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Congressman" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Congressman"(s) SELECT DISTINCT t0.s FROM "dbrdf_Congressman_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Congressman_delta_old";
        INSERT INTO "dbrdf_Congressman_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Congressman_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Congressman_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_mostWins_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mostWins_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_mostWins" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mostWins_delta_old" ON "dbrdf_mostWins_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mostWins_delta_old" ON "dbrdf_mostWins_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mostWins_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/mostWins$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/mostWins$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_mostWins_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_mostWins_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_mostWins" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/mostWins$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/mostWins$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_mostWins_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_mostWins_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_mostWins" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_mostWins"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_mostWins_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_mostWins_delta_old";
        INSERT INTO "dbrdf_mostWins_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_mostWins_delta_new" t0;
        TRUNCATE TABLE "dbrdf_mostWins_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_largestWin_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_largestWin_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_largestWin" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_largestWin_delta_old" ON "dbrdf_largestWin_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_largestWin_delta_old" ON "dbrdf_largestWin_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_largestWin_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/largestWin$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/largestWin$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_largestWin_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_largestWin_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_largestWin" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/largestWin$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/largestWin$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_largestWin_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_largestWin_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_largestWin" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_largestWin"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_largestWin_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_largestWin_delta_old";
        INSERT INTO "dbrdf_largestWin_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_largestWin_delta_new" t0;
        TRUNCATE TABLE "dbrdf_largestWin_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_ranking_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ranking_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_ranking" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ranking_delta_old" ON "dbrdf_ranking_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ranking_delta_old" ON "dbrdf_ranking_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ranking_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/ranking$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/ranking$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_ranking_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_ranking_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_ranking" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/ranking$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/ranking$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_ranking_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_ranking_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_ranking" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_ranking"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_ranking_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_ranking_delta_old";
        INSERT INTO "dbrdf_ranking_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_ranking_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ranking_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_finalPublicationYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_finalPublicationYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_finalPublicationYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_finalPublicationYear_delta_old" ON "dbrdf_finalPublicationYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_finalPublicationYear_delta_old" ON "dbrdf_finalPublicationYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_finalPublicationYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/finalPublicationYear$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/finalPublicationYear$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_finalPublicationYear_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_finalPublicationYear_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_finalPublicationYear" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/finalPublicationYear$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/finalPublicationYear$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_finalPublicationYear_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_finalPublicationYear_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_finalPublicationYear" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_finalPublicationYear"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_finalPublicationYear_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_finalPublicationYear_delta_old";
        INSERT INTO "dbrdf_finalPublicationYear_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_finalPublicationYear_delta_new" t0;
        TRUNCATE TABLE "dbrdf_finalPublicationYear_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_anthem_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_anthem_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_anthem" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_anthem_delta_old" ON "dbrdf_anthem_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_anthem_delta_old" ON "dbrdf_anthem_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_anthem_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/anthem$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/anthem$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_anthem_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_anthem_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_anthem" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/anthem$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/anthem$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_anthem_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_anthem_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_anthem" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_anthem"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_anthem_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_anthem_delta_old";
        INSERT INTO "dbrdf_anthem_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_anthem_delta_new" t0;
        TRUNCATE TABLE "dbrdf_anthem_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_beatifiedPlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_beatifiedPlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_beatifiedPlace" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_beatifiedPlace" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_beatifiedPlace" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_waistSize_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_waistSize_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_waistSize" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_waistSize_delta_old" ON "dbrdf_waistSize_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_waistSize_delta_old" ON "dbrdf_waistSize_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_waistSize_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/waistSize$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/waistSize$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_waistSize_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_waistSize_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_waistSize" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/waistSize$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/waistSize$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_waistSize_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_waistSize_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_waistSize" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_waistSize"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_waistSize_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_waistSize_delta_old";
        INSERT INTO "dbrdf_waistSize_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_waistSize_delta_new" t0;
        TRUNCATE TABLE "dbrdf_waistSize_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_formerCallsign_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_formerCallsign_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_formerCallsign" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_formerCallsign_delta_old" ON "dbrdf_formerCallsign_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_formerCallsign_delta_old" ON "dbrdf_formerCallsign_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerCallsign_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/formerCallsign$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/formerCallsign$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_formerCallsign_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_formerCallsign_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_formerCallsign" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/formerCallsign$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/formerCallsign$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_formerCallsign_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_formerCallsign_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_formerCallsign" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_formerCallsign"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_formerCallsign_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_formerCallsign_delta_old";
        INSERT INTO "dbrdf_formerCallsign_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_formerCallsign_delta_new" t0;
        TRUNCATE TABLE "dbrdf_formerCallsign_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_previousEvent_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_previousEvent_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_previousEvent" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_previousEvent_delta_old" ON "dbrdf_previousEvent_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_previousEvent_delta_old" ON "dbrdf_previousEvent_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_previousEvent_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/previousEvent$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/previousEvent$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_previousEvent_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_previousEvent_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_previousEvent" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/previousEvent$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/previousEvent$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_previousEvent_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_previousEvent_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_previousEvent" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_previousEvent"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_previousEvent_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_previousEvent_delta_old";
        INSERT INTO "dbrdf_previousEvent_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_previousEvent_delta_new" t0;
        TRUNCATE TABLE "dbrdf_previousEvent_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_headquarter_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_headquarter_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_headquarter" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_headquarter_delta_old" ON "dbrdf_headquarter_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_headquarter_delta_old" ON "dbrdf_headquarter_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_headquarter_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/headquarter$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/headquarter$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_headquarter_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_headquarter_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_headquarter" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/headquarter$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/headquarter$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_headquarter_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_headquarter_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_headquarter" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_headquarter"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_headquarter_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_headquarter_delta_old";
        INSERT INTO "dbrdf_headquarter_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_headquarter_delta_new" t0;
        TRUNCATE TABLE "dbrdf_headquarter_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_alpsGroup_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_alpsGroup_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_alpsGroup" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_alpsGroup_delta_old" ON "dbrdf_alpsGroup_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_alpsGroup_delta_old" ON "dbrdf_alpsGroup_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsGroup_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/alpsGroup$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/alpsGroup$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_alpsGroup_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_alpsGroup_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_alpsGroup" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/alpsGroup$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/alpsGroup$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_alpsGroup_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_alpsGroup_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_alpsGroup" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_alpsGroup"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_alpsGroup_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_alpsGroup_delta_old";
        INSERT INTO "dbrdf_alpsGroup_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_alpsGroup_delta_new" t0;
        TRUNCATE TABLE "dbrdf_alpsGroup_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 999
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_runwayDesignation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_runwayDesignation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_runwayDesignation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_runwayDesignation_delta_old" ON "dbrdf_runwayDesignation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_runwayDesignation_delta_old" ON "dbrdf_runwayDesignation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_runwayDesignation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/runwayDesignation$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/runwayDesignation$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_runwayDesignation_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_runwayDesignation_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_runwayDesignation" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/runwayDesignation$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/runwayDesignation$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_runwayDesignation_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_runwayDesignation_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_runwayDesignation" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_runwayDesignation"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_runwayDesignation_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_runwayDesignation_delta_old";
        INSERT INTO "dbrdf_runwayDesignation_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_runwayDesignation_delta_new" t0;
        TRUNCATE TABLE "dbrdf_runwayDesignation_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_lastSeason_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lastSeason_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lastSeason" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lastSeason_delta_old" ON "dbrdf_lastSeason_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lastSeason_delta_old" ON "dbrdf_lastSeason_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastSeason_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/lastSeason$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/lastSeason$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_lastSeason_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_lastSeason_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_lastSeason" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/lastSeason$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/lastSeason$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_lastSeason_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_lastSeason_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_lastSeason" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_lastSeason"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lastSeason_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_lastSeason_delta_old";
        INSERT INTO "dbrdf_lastSeason_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lastSeason_delta_new" t0;
        TRUNCATE TABLE "dbrdf_lastSeason_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_dockedTime_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dockedTime_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_dockedTime" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dockedTime_delta_old" ON "dbrdf_dockedTime_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dockedTime_delta_old" ON "dbrdf_dockedTime_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dockedTime_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/dockedTime$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/dockedTime$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_dockedTime_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_dockedTime_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_dockedTime" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/dockedTime$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/dockedTime$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_dockedTime_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_dockedTime_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_dockedTime" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_dockedTime"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_dockedTime_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_dockedTime_delta_old";
        INSERT INTO "dbrdf_dockedTime_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_dockedTime_delta_new" t0;
        TRUNCATE TABLE "dbrdf_dockedTime_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_associatedAct_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_associatedAct_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_associatedAct" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_associatedAct_delta_old" ON "dbrdf_associatedAct_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_associatedAct_delta_old" ON "dbrdf_associatedAct_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_associatedAct_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/associatedAct$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/associatedAct$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_associatedAct_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_associatedAct_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_associatedAct" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/associatedAct$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/associatedAct$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_associatedAct_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_associatedAct_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_associatedAct" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_associatedAct"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_associatedAct_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_associatedAct_delta_old";
        INSERT INTO "dbrdf_associatedAct_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_associatedAct_delta_new" t0;
        TRUNCATE TABLE "dbrdf_associatedAct_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

