        INSERT INTO "dbrdf_lastFlightStartDate_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_lastFlightStartDate_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_lastFlightStartDate" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 312
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_carNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_carNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_carNumber" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_carNumber_delta_old" ON "dbrdf_carNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_carNumber_delta_old" ON "dbrdf_carNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_carNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 313
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_minimumTemperature0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_minimumTemperature_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_minimumTemperature_delta_old0";
        INSERT INTO "dbrdf_minimumTemperature_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_minimumTemperature_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_minimumTemperature_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 314
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_satScore_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_satScore_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_satScore" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_satScore_delta_old" ON "dbrdf_satScore_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_satScore_delta_old" ON "dbrdf_satScore_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_satScore_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 315
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_pseudonym_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_pseudonym_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_pseudonym" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_pseudonym_delta_old" ON "dbrdf_pseudonym_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_pseudonym_delta_old" ON "dbrdf_pseudonym_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_pseudonym_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 316
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_TradeUnion"(s) SELECT DISTINCT t0.s FROM "dbrdf_TradeUnion_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_TradeUnion_delta_old";
        INSERT INTO "dbrdf_TradeUnion_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_TradeUnion_delta_new" t0;
        TRUNCATE TABLE "dbrdf_TradeUnion_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 317
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_capitalPosition_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_capitalPosition_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_capitalPosition" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_capitalPosition_delta_old" ON "dbrdf_capitalPosition_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_capitalPosition_delta_old" ON "dbrdf_capitalPosition_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_capitalPosition_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 318
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_timeInSpace1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_timeInSpace_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_timeInSpace_delta_old1";
        INSERT INTO "dbrdf_timeInSpace_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_timeInSpace_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_timeInSpace_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 319
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_championships_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_championships_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_championships" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_championships_delta_old" ON "dbrdf_championships_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_championships_delta_old" ON "dbrdf_championships_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_championships_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 320
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_geneLocationEnd_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_geneLocationEnd_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_geneLocationEnd" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_geneLocationEnd_delta_old" ON "dbrdf_geneLocationEnd_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_geneLocationEnd_delta_old" ON "dbrdf_geneLocationEnd_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_geneLocationEnd_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 321
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_timeZone_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_timeZone_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_timeZone" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_timeZone_delta_old" ON "dbrdf_timeZone_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_timeZone_delta_old" ON "dbrdf_timeZone_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_timeZone_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 322
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_height_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_height_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_height0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_height_delta_old0" ON "dbrdf_height_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_height_delta_old0" ON "dbrdf_height_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_height_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_height0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_height_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_height_delta_old0";
        INSERT INTO "dbrdf_height_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_height_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_height_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 323
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_handedness_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_handedness_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_handedness" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_handedness_delta_old" ON "dbrdf_handedness_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_handedness_delta_old" ON "dbrdf_handedness_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_handedness_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 324
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Mammal"(s) SELECT DISTINCT t0.s FROM "dbrdf_Mammal_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Mammal_delta_old";
        INSERT INTO "dbrdf_Mammal_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Mammal_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Mammal_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 325
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_role_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_role_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_role" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_role_delta_old" ON "dbrdf_role_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_role_delta_old" ON "dbrdf_role_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_role_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 326
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_locationIdentifier_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_locationIdentifier_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_locationIdentifier" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_locationIdentifier_delta_old" ON "dbrdf_locationIdentifier_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_locationIdentifier_delta_old" ON "dbrdf_locationIdentifier_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_locationIdentifier_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 327
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_season_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_season_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_season" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_season_delta_old" ON "dbrdf_season_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_season_delta_old" ON "dbrdf_season_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_season_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 328
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_endDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_endDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_endDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_endDate_delta_old" ON "dbrdf_endDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_endDate_delta_old" ON "dbrdf_endDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_endDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 329
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_canonizedDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_canonizedDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_canonizedDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_canonizedDate_delta_old" ON "dbrdf_canonizedDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_canonizedDate_delta_old" ON "dbrdf_canonizedDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_canonizedDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 330
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mountainRange_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mountainRange_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_mountainRange" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mountainRange_delta_old" ON "dbrdf_mountainRange_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mountainRange_delta_old" ON "dbrdf_mountainRange_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mountainRange_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 331
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lunarRover_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lunarRover_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lunarRover" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lunarRover_delta_old" ON "dbrdf_lunarRover_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lunarRover_delta_old" ON "dbrdf_lunarRover_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lunarRover_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 332
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lieutenant_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lieutenant_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lieutenant" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lieutenant_delta_old" ON "dbrdf_lieutenant_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lieutenant_delta_old" ON "dbrdf_lieutenant_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lieutenant_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 333
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationDensity_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_populationDensity_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_populationDensity" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_populationDensity_delta_old" ON "dbrdf_populationDensity_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_populationDensity_delta_old" ON "dbrdf_populationDensity_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationDensity_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 334
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Fish"(s) SELECT DISTINCT t0.s FROM "dbrdf_Fish_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Fish_delta_old";
        INSERT INTO "dbrdf_Fish_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Fish_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Fish_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 335
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumBoatBeam_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_maximumBoatBeam_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_maximumBoatBeam" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_maximumBoatBeam_delta_old" ON "dbrdf_maximumBoatBeam_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_maximumBoatBeam_delta_old" ON "dbrdf_maximumBoatBeam_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumBoatBeam_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 336
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lunarOrbitTime_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lunarOrbitTime_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lunarOrbitTime0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lunarOrbitTime_delta_old0" ON "dbrdf_lunarOrbitTime_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_lunarOrbitTime_delta_old0" ON "dbrdf_lunarOrbitTime_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lunarOrbitTime_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_lunarOrbitTime0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lunarOrbitTime_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_lunarOrbitTime_delta_old0";
        INSERT INTO "dbrdf_lunarOrbitTime_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lunarOrbitTime_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_lunarOrbitTime_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 337
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_retiredRocket_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_retiredRocket_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_retiredRocket" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_retiredRocket_delta_old" ON "dbrdf_retiredRocket_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_retiredRocket_delta_old" ON "dbrdf_retiredRocket_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_retiredRocket_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 338
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfSuites_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfSuites_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfSuites" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfSuites_delta_old" ON "dbrdf_numberOfSuites_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfSuites_delta_old" ON "dbrdf_numberOfSuites_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfSuites_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 339
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_review_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_review_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_review" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_review_delta_old" ON "dbrdf_review_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_review_delta_old" ON "dbrdf_review_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_review_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 340
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_almaMater_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_almaMater_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_almaMater" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_almaMater_delta_old" ON "dbrdf_almaMater_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_almaMater_delta_old" ON "dbrdf_almaMater_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_almaMater_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 341
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_PolishKing"(s) SELECT DISTINCT t0.s FROM "dbrdf_PolishKing_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_PolishKing_delta_old";
        INSERT INTO "dbrdf_PolishKing_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_PolishKing_delta_new" t0;
        TRUNCATE TABLE "dbrdf_PolishKing_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 342
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_iucnCategory_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_iucnCategory_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_iucnCategory" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_iucnCategory_delta_old" ON "dbrdf_iucnCategory_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_iucnCategory_delta_old" ON "dbrdf_iucnCategory_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_iucnCategory_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 343
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_production_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_production_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_production" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_production_delta_old" ON "dbrdf_production_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_production_delta_old" ON "dbrdf_production_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_production_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 344
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_BritishRoyalty"(s) SELECT DISTINCT t0.s FROM "dbrdf_BritishRoyalty_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_BritishRoyalty_delta_old";
        INSERT INTO "dbrdf_BritishRoyalty_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_BritishRoyalty_delta_new" t0;
        TRUNCATE TABLE "dbrdf_BritishRoyalty_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 345
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mainOrgan_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mainOrgan_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_mainOrgan" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mainOrgan_delta_old" ON "dbrdf_mainOrgan_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mainOrgan_delta_old" ON "dbrdf_mainOrgan_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mainOrgan_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 346
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_SambaSchool"(s) SELECT DISTINCT t0.s FROM "dbrdf_SambaSchool_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SambaSchool_delta_old";
        INSERT INTO "dbrdf_SambaSchool_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SambaSchool_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SambaSchool_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 347
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ideology_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ideology_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_ideology" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ideology_delta_old" ON "dbrdf_ideology_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ideology_delta_old" ON "dbrdf_ideology_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ideology_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 348
    ---- DEPENDS ON: 347, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Ideology>(?X1) :- <http://dbpedia.org/ontology/ideology>(?X,?X1) .
    INSERT INTO "dbrdf_Ideology"(s) SELECT DISTINCT t0.o FROM "dbrdf_ideology" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Ideology" ex WHERE ex.s = t0.o);
    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_Ideology_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Ideology_delta_old"(s) SELECT t0.s FROM "dbrdf_Ideology" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Ideology_delta_old" ON "dbrdf_Ideology_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Ideology_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/Ideology$delta_new>(?Y) :- <http://dbpedia.org/ontology/Ideology$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Ideology_delta_new"(s) SELECT t1.o FROM "dbrdf_Ideology_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Ideology" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Ideology"(s) SELECT DISTINCT t0.s FROM "dbrdf_Ideology_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Ideology_delta_old";
        INSERT INTO "dbrdf_Ideology_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Ideology_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Ideology_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 349
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_hasSurfaceForm_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_hasSurfaceForm_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_hasSurfaceForm" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_hasSurfaceForm_delta_old" ON "dbrdf_hasSurfaceForm_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_hasSurfaceForm_delta_old" ON "dbrdf_hasSurfaceForm_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_hasSurfaceForm_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 350
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_movement_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_movement_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_movement" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_movement_delta_old" ON "dbrdf_movement_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_movement_delta_old" ON "dbrdf_movement_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_movement_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 351
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 352
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 353
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 354
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 355
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 356
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 357
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 358
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 359
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 360
    ---- DEPENDS ON: 236, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Theatre>(?X) :- <http://dbpedia.org/ontology/currentProduction>(?X,?X1) .
    INSERT INTO "dbrdf_Theatre"(s) SELECT DISTINCT t0.s FROM "dbrdf_currentProduction" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Theatre" 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_Theatre_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Theatre_delta_old"(s) SELECT t0.s FROM "dbrdf_Theatre" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Theatre_delta_old" ON "dbrdf_Theatre_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Theatre_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Theatre"(s) SELECT DISTINCT t0.s FROM "dbrdf_Theatre_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Theatre_delta_old";
        INSERT INTO "dbrdf_Theatre_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Theatre_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Theatre_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 361
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 362
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 363
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 364
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 365
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 366
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 367
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 368
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_President_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_President_delta_old"(s) SELECT t0.s FROM "dbrdf_President" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_President_delta_old" ON "dbrdf_President_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_President_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_President"(s) SELECT DISTINCT t0.s FROM "dbrdf_President_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_President_delta_old";
        INSERT INTO "dbrdf_President_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_President_delta_new" t0;
        TRUNCATE TABLE "dbrdf_President_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 369
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 370
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 371
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 372
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 373
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 374
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Cyclist_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Cyclist_delta_old"(s) SELECT t0.s FROM "dbrdf_Cyclist" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Cyclist_delta_old" ON "dbrdf_Cyclist_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Cyclist_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Cyclist"(s) SELECT DISTINCT t0.s FROM "dbrdf_Cyclist_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Cyclist_delta_old";
        INSERT INTO "dbrdf_Cyclist_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Cyclist_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Cyclist_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 375
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 376
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 377
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 378
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 379
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 380
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 381
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lunarSurfaceTime_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lunarSurfaceTime_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lunarSurfaceTime" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lunarSurfaceTime_delta_old" ON "dbrdf_lunarSurfaceTime_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lunarSurfaceTime_delta_old" ON "dbrdf_lunarSurfaceTime_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lunarSurfaceTime_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 382
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 383
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 384
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_BadmintonPlayer_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_BadmintonPlayer_delta_old"(s) SELECT t0.s FROM "dbrdf_BadmintonPlayer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_BadmintonPlayer_delta_old" ON "dbrdf_BadmintonPlayer_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_BadmintonPlayer_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_BadmintonPlayer"(s) SELECT DISTINCT t0.s FROM "dbrdf_BadmintonPlayer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_BadmintonPlayer_delta_old";
        INSERT INTO "dbrdf_BadmintonPlayer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_BadmintonPlayer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_BadmintonPlayer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 385
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 386
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 387
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 388
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 389
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 390
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 391
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 392
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 393
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 394
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_weight_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_weight_delta_old1"(s, o) SELECT t0.s, t0.o FROM "dbrdf_weight1" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_weight_delta_old1" ON "dbrdf_weight_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_weight_delta_old1" ON "dbrdf_weight_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_weight_delta_new1"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 395
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 396
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 397
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 398
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 399
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 400
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 401
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 402
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 403
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 404
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 405
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 406
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 407
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 408
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 409
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_eTeatrId_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_eTeatrId_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_eTeatrId" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_eTeatrId_delta_old" ON "dbrdf_eTeatrId_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_eTeatrId_delta_old" ON "dbrdf_eTeatrId_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_eTeatrId_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 410
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rankingsSingles_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rankingsSingles_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_rankingsSingles" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rankingsSingles_delta_old" ON "dbrdf_rankingsSingles_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rankingsSingles_delta_old" ON "dbrdf_rankingsSingles_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rankingsSingles_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 411
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_retired_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_retired_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_retired" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_retired_delta_old" ON "dbrdf_retired_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_retired_delta_old" ON "dbrdf_retired_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_retired_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 412
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfVolunteers_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfVolunteers_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfVolunteers" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfVolunteers_delta_old" ON "dbrdf_numberOfVolunteers_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfVolunteers_delta_old" ON "dbrdf_numberOfVolunteers_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfVolunteers_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 413
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_supplementalDraftRound_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_supplementalDraftRound_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_supplementalDraftRound" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_supplementalDraftRound_delta_old" ON "dbrdf_supplementalDraftRound_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_supplementalDraftRound_delta_old" ON "dbrdf_supplementalDraftRound_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_supplementalDraftRound_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 414
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_casNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_casNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_casNumber" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_casNumber_delta_old" ON "dbrdf_casNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_casNumber_delta_old" ON "dbrdf_casNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_casNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 415
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_crew_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_crew_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_crew" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_crew_delta_old" ON "dbrdf_crew_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_crew_delta_old" ON "dbrdf_crew_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_crew_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 416
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_developer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_developer_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_developer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_developer_delta_old" ON "dbrdf_developer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_developer_delta_old" ON "dbrdf_developer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_developer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 417
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Bird"(s) SELECT DISTINCT t0.s FROM "dbrdf_Bird_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Bird_delta_old";
        INSERT INTO "dbrdf_Bird_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Bird_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Bird_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 418
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_iobdbId_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_iobdbId_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_iobdbId" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_iobdbId_delta_old" ON "dbrdf_iobdbId_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_iobdbId_delta_old" ON "dbrdf_iobdbId_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_iobdbId_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 419
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_place_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_place_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_place" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_place_delta_old" ON "dbrdf_place_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_place_delta_old" ON "dbrdf_place_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_place_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 420
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_averageSpeed0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_averageSpeed_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_averageSpeed_delta_old0";
        INSERT INTO "dbrdf_averageSpeed_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_averageSpeed_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_averageSpeed_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 421
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtNWIDE_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtNWIDE_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_winsAtNWIDE" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtNWIDE_delta_old" ON "dbrdf_winsAtNWIDE_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtNWIDE_delta_old" ON "dbrdf_winsAtNWIDE_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtNWIDE_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 422
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rebuilder_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rebuilder_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_rebuilder" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rebuilder_delta_old" ON "dbrdf_rebuilder_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rebuilder_delta_old" ON "dbrdf_rebuilder_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rebuilder_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 423
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_CurlingLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_CurlingLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_CurlingLeague_delta_old";
        INSERT INTO "dbrdf_CurlingLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_CurlingLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_CurlingLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 424
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_GolfLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_GolfLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_GolfLeague_delta_old";
        INSERT INTO "dbrdf_GolfLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_GolfLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_GolfLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 425
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfClassrooms_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfClassrooms_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfClassrooms" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfClassrooms_delta_old" ON "dbrdf_numberOfClassrooms_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfClassrooms_delta_old" ON "dbrdf_numberOfClassrooms_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfClassrooms_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 426
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceConfluencePlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sourceConfluencePlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_sourceConfluencePlace" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sourceConfluencePlace_delta_old" ON "dbrdf_sourceConfluencePlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sourceConfluencePlace_delta_old" ON "dbrdf_sourceConfluencePlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceConfluencePlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 427
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_isPartOfWineRegion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_isPartOfWineRegion_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_isPartOfWineRegion" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_isPartOfWineRegion_delta_old" ON "dbrdf_isPartOfWineRegion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_isPartOfWineRegion_delta_old" ON "dbrdf_isPartOfWineRegion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_isPartOfWineRegion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 428
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_combatant_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_combatant_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_combatant" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_combatant_delta_old" ON "dbrdf_combatant_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_combatant_delta_old" ON "dbrdf_combatant_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_combatant_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 429
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Journalist"(s) SELECT DISTINCT t0.s FROM "dbrdf_Journalist_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Journalist_delta_old";
        INSERT INTO "dbrdf_Journalist_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Journalist_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Journalist_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 430
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_majorityLeader_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_majorityLeader_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_majorityLeader" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_majorityLeader_delta_old" ON "dbrdf_majorityLeader_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_majorityLeader_delta_old" ON "dbrdf_majorityLeader_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_majorityLeader_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 431
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_circuitName_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_circuitName_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_circuitName" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_circuitName_delta_old" ON "dbrdf_circuitName_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_circuitName_delta_old" ON "dbrdf_circuitName_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_circuitName_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 432
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ascentDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ascentDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_ascentDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ascentDate_delta_old" ON "dbrdf_ascentDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ascentDate_delta_old" ON "dbrdf_ascentDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ascentDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 433
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_isPartOfRoute_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_isPartOfRoute_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_isPartOfRoute" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_isPartOfRoute_delta_old" ON "dbrdf_isPartOfRoute_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_isPartOfRoute_delta_old" ON "dbrdf_isPartOfRoute_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_isPartOfRoute_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 434
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_circuitLength_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_circuitLength_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_circuitLength" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_circuitLength_delta_old" ON "dbrdf_circuitLength_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_circuitLength_delta_old" ON "dbrdf_circuitLength_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_circuitLength_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 435
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sales_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sales_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_sales" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sales_delta_old" ON "dbrdf_sales_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sales_delta_old" ON "dbrdf_sales_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sales_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 436
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_fastestLap_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_fastestLap_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_fastestLap" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_fastestLap_delta_old" ON "dbrdf_fastestLap_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_fastestLap_delta_old" ON "dbrdf_fastestLap_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_fastestLap_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 437
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_screenActorsGuildAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_screenActorsGuildAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_screenActorsGuildAward" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_screenActorsGuildAward_delta_old" ON "dbrdf_screenActorsGuildAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_screenActorsGuildAward_delta_old" ON "dbrdf_screenActorsGuildAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_screenActorsGuildAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 438
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_capitalElevation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_capitalElevation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_capitalElevation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_capitalElevation_delta_old" ON "dbrdf_capitalElevation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_capitalElevation_delta_old" ON "dbrdf_capitalElevation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_capitalElevation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 439
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cluster_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cluster_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_cluster" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cluster_delta_old" ON "dbrdf_cluster_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_cluster_delta_old" ON "dbrdf_cluster_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cluster_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 440
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_polishFilmAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_polishFilmAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_polishFilmAward" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_polishFilmAward_delta_old" ON "dbrdf_polishFilmAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_polishFilmAward_delta_old" ON "dbrdf_polishFilmAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_polishFilmAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 441
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Conifer"(s) SELECT DISTINCT t0.s FROM "dbrdf_Conifer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Conifer_delta_old";
        INSERT INTO "dbrdf_Conifer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Conifer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Conifer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 442
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dissolutionDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dissolutionDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_dissolutionDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dissolutionDate_delta_old" ON "dbrdf_dissolutionDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dissolutionDate_delta_old" ON "dbrdf_dissolutionDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dissolutionDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 443
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_costumeDesigner_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_costumeDesigner_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_costumeDesigner" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_costumeDesigner_delta_old" ON "dbrdf_costumeDesigner_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_costumeDesigner_delta_old" ON "dbrdf_costumeDesigner_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_costumeDesigner_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 444
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dressCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dressCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_dressCode" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dressCode_delta_old" ON "dbrdf_dressCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dressCode_delta_old" ON "dbrdf_dressCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dressCode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 445
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lunarSampleMass_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lunarSampleMass_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lunarSampleMass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lunarSampleMass_delta_old" ON "dbrdf_lunarSampleMass_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lunarSampleMass_delta_old" ON "dbrdf_lunarSampleMass_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lunarSampleMass_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_lunarSampleMass"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lunarSampleMass_delta_new" 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_old";
        INSERT INTO "dbrdf_lunarSampleMass_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lunarSampleMass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_lunarSampleMass_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 446
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfSpeakers_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfSpeakers_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfSpeakers" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfSpeakers_delta_old" ON "dbrdf_numberOfSpeakers_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfSpeakers_delta_old" ON "dbrdf_numberOfSpeakers_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfSpeakers_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 447
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_updated_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_updated_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_updated" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_updated_delta_old" ON "dbrdf_updated_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_updated_delta_old" ON "dbrdf_updated_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_updated_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 448
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_fileSize_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_fileSize_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_fileSize" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_fileSize_delta_old" ON "dbrdf_fileSize_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_fileSize_delta_old" ON "dbrdf_fileSize_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_fileSize_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 449
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_subjectOfPlay_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_subjectOfPlay_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_subjectOfPlay" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_subjectOfPlay_delta_old" ON "dbrdf_subjectOfPlay_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_subjectOfPlay_delta_old" ON "dbrdf_subjectOfPlay_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_subjectOfPlay_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 450
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_setDesigner_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_setDesigner_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_setDesigner" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_setDesigner_delta_old" ON "dbrdf_setDesigner_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_setDesigner_delta_old" ON "dbrdf_setDesigner_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_setDesigner_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 451
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_impactFactorAsOf_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_impactFactorAsOf_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_impactFactorAsOf" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_impactFactorAsOf_delta_old" ON "dbrdf_impactFactorAsOf_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_impactFactorAsOf_delta_old" ON "dbrdf_impactFactorAsOf_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_impactFactorAsOf_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 452
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_administrativeCollectivity_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_administrativeCollectivity_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_administrativeCollectivity" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_administrativeCollectivity_delta_old" ON "dbrdf_administrativeCollectivity_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_administrativeCollectivity_delta_old" ON "dbrdf_administrativeCollectivity_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_administrativeCollectivity_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 453
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_hubAirport_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_hubAirport_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_hubAirport" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_hubAirport_delta_old" ON "dbrdf_hubAirport_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_hubAirport_delta_old" ON "dbrdf_hubAirport_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_hubAirport_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 454
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_technique_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_technique_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_technique" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_technique_delta_old" ON "dbrdf_technique_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_technique_delta_old" ON "dbrdf_technique_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_technique_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 455
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftType_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftType_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_aircraftType" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftType_delta_old" ON "dbrdf_aircraftType_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftType_delta_old" ON "dbrdf_aircraftType_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftType_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 456
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_minimumElevation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_minimumElevation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_minimumElevation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_minimumElevation_delta_old" ON "dbrdf_minimumElevation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_minimumElevation_delta_old" ON "dbrdf_minimumElevation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_minimumElevation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 457
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsSoiusaCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_alpsSoiusaCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_alpsSoiusaCode" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_alpsSoiusaCode_delta_old" ON "dbrdf_alpsSoiusaCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_alpsSoiusaCode_delta_old" ON "dbrdf_alpsSoiusaCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsSoiusaCode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 458
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_managementElevation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_managementElevation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_managementElevation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_managementElevation_delta_old" ON "dbrdf_managementElevation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_managementElevation_delta_old" ON "dbrdf_managementElevation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_managementElevation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 459
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_musicFusionGenre_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_musicFusionGenre_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_musicFusionGenre" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_musicFusionGenre_delta_old" ON "dbrdf_musicFusionGenre_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_musicFusionGenre_delta_old" ON "dbrdf_musicFusionGenre_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_musicFusionGenre_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 460
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_managerClub_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_managerClub_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_managerClub" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_managerClub_delta_old" ON "dbrdf_managerClub_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_managerClub_delta_old" ON "dbrdf_managerClub_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_managerClub_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 461
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceState_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sourceState_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_sourceState" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sourceState_delta_old" ON "dbrdf_sourceState_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sourceState_delta_old" ON "dbrdf_sourceState_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceState_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 462
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtSun_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtSun_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_winsAtSun" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtSun_delta_old" ON "dbrdf_winsAtSun_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtSun_delta_old" ON "dbrdf_winsAtSun_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtSun_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 463
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_americanComedyAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_americanComedyAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_americanComedyAward" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_americanComedyAward_delta_old" ON "dbrdf_americanComedyAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_americanComedyAward_delta_old" ON "dbrdf_americanComedyAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_americanComedyAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 464
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cmykCoordinateBlack_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cmykCoordinateBlack_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_cmykCoordinateBlack" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cmykCoordinateBlack_delta_old" ON "dbrdf_cmykCoordinateBlack_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_cmykCoordinateBlack_delta_old" ON "dbrdf_cmykCoordinateBlack_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cmykCoordinateBlack_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 465
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nrhpType_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nrhpType_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_nrhpType" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nrhpType_delta_old" ON "dbrdf_nrhpType_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nrhpType_delta_old" ON "dbrdf_nrhpType_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nrhpType_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 466
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_RugbyPlayer"(s) SELECT DISTINCT t0.s FROM "dbrdf_RugbyPlayer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_RugbyPlayer_delta_old";
        INSERT INTO "dbrdf_RugbyPlayer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_RugbyPlayer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_RugbyPlayer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 467
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastElectionDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lastElectionDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lastElectionDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lastElectionDate_delta_old" ON "dbrdf_lastElectionDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lastElectionDate_delta_old" ON "dbrdf_lastElectionDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastElectionDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 468
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_distributingLabel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_distributingLabel_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_distributingLabel" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_distributingLabel_delta_old" ON "dbrdf_distributingLabel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_distributingLabel_delta_old" ON "dbrdf_distributingLabel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_distributingLabel_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 469
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_structuralSystem_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_structuralSystem_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_structuralSystem" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_structuralSystem_delta_old" ON "dbrdf_structuralSystem_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_structuralSystem_delta_old" ON "dbrdf_structuralSystem_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_structuralSystem_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 470
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_distance_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_distance_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_distance0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_distance_delta_old0" ON "dbrdf_distance_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_distance_delta_old0" ON "dbrdf_distance_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_distance_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_distance0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_distance_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_distance_delta_old0";
        INSERT INTO "dbrdf_distance_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_distance_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_distance_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 471
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_binomial_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_binomial_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_binomial" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_binomial_delta_old" ON "dbrdf_binomial_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_binomial_delta_old" ON "dbrdf_binomial_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_binomial_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 472
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_elevation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_elevation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_elevation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_elevation_delta_old" ON "dbrdf_elevation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_elevation_delta_old" ON "dbrdf_elevation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_elevation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 473
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Ambassador"(s) SELECT DISTINCT t0.s FROM "dbrdf_Ambassador_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Ambassador_delta_old";
        INSERT INTO "dbrdf_Ambassador_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Ambassador_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Ambassador_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 474
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_shoots_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_shoots_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_shoots" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_shoots_delta_old" ON "dbrdf_shoots_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_shoots_delta_old" ON "dbrdf_shoots_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_shoots_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 475
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstAppearance_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstAppearance_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_firstAppearance" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstAppearance_delta_old" ON "dbrdf_firstAppearance_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstAppearance_delta_old" ON "dbrdf_firstAppearance_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstAppearance_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 476
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nationalTopographicSystemMapNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nationalTopographicSystemMapNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_nationalTopographicSystemMapNumber" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nationalTopographicSystemMapNumber_delta_old" ON "dbrdf_nationalTopographicSystemMapNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nationalTopographicSystemMapNumber_delta_old" ON "dbrdf_nationalTopographicSystemMapNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nationalTopographicSystemMapNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 477
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_ChemicalElement"(s) SELECT DISTINCT t0.s FROM "dbrdf_ChemicalElement_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_ChemicalElement_delta_old";
        INSERT INTO "dbrdf_ChemicalElement_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_ChemicalElement_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ChemicalElement_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 478
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dateOfBurial_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dateOfBurial_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_dateOfBurial" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dateOfBurial_delta_old" ON "dbrdf_dateOfBurial_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dateOfBurial_delta_old" ON "dbrdf_dateOfBurial_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dateOfBurial_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 479
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfRockets_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfRockets_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfRockets" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfRockets_delta_old" ON "dbrdf_numberOfRockets_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfRockets_delta_old" ON "dbrdf_numberOfRockets_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfRockets_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 480
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfStaff_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfStaff_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfStaff" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfStaff_delta_old" ON "dbrdf_numberOfStaff_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfStaff_delta_old" ON "dbrdf_numberOfStaff_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfStaff_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 481
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_channel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_channel_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_channel" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_channel_delta_old" ON "dbrdf_channel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_channel_delta_old" ON "dbrdf_channel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_channel_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 482
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lowestRegion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lowestRegion_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lowestRegion" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lowestRegion_delta_old" ON "dbrdf_lowestRegion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lowestRegion_delta_old" ON "dbrdf_lowestRegion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lowestRegion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 483
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_managementPlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_managementPlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_managementPlace" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_managementPlace_delta_old" ON "dbrdf_managementPlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_managementPlace_delta_old" ON "dbrdf_managementPlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_managementPlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 484
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_boilingPoint_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_boilingPoint_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_boilingPoint0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_boilingPoint_delta_old0" ON "dbrdf_boilingPoint_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_boilingPoint_delta_old0" ON "dbrdf_boilingPoint_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_boilingPoint_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 485
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_voltageOfElectrification_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_voltageOfElectrification_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_voltageOfElectrification" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_voltageOfElectrification_delta_old" ON "dbrdf_voltageOfElectrification_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_voltageOfElectrification_delta_old" ON "dbrdf_voltageOfElectrification_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_voltageOfElectrification_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 486
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_period_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_period_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_period" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_period_delta_old" ON "dbrdf_period_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_period_delta_old" ON "dbrdf_period_delta_old"(o);
