        TRUNCATE TABLE "dbrdf_statisticLabel_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1339
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_incumbent_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_incumbent_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_incumbent" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_incumbent_delta_old" ON "dbrdf_incumbent_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_incumbent_delta_old" ON "dbrdf_incumbent_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_incumbent_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1340
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nerve_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nerve_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_nerve" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nerve_delta_old" ON "dbrdf_nerve_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nerve_delta_old" ON "dbrdf_nerve_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nerve_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1341
    ---- DEPENDS ON: 1340, 1082, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- [Rule] <http://dbpedia.org/ontology/Nerve>(?X1) :- <http://dbpedia.org/ontology/nerve>(?X,?X1) .
    INSERT INTO "dbrdf_Nerve"(s) SELECT DISTINCT t0.o FROM "dbrdf_nerve" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Nerve" 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_Nerve_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Nerve_delta_old"(s) SELECT t0.s FROM "dbrdf_Nerve" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Nerve_delta_old" ON "dbrdf_Nerve_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Nerve_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/Nerve$delta_new>(?Y) :- <http://dbpedia.org/ontology/Nerve$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Nerve_delta_new"(s) SELECT t1.o FROM "dbrdf_Nerve_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Nerve" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Nerve"(s) SELECT DISTINCT t0.s FROM "dbrdf_Nerve_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Nerve_delta_old";
        INSERT INTO "dbrdf_Nerve_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Nerve_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Nerve_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1342
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_SpeedwayLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_SpeedwayLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SpeedwayLeague_delta_old";
        INSERT INTO "dbrdf_SpeedwayLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SpeedwayLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SpeedwayLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1343
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_access_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_access_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_access" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_access_delta_old" ON "dbrdf_access_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_access_delta_old" ON "dbrdf_access_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_access_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1344
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfParkingSpaces_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfParkingSpaces_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfParkingSpaces" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfParkingSpaces_delta_old" ON "dbrdf_numberOfParkingSpaces_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfParkingSpaces_delta_old" ON "dbrdf_numberOfParkingSpaces_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfParkingSpaces_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1345
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_notifyDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_notifyDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_notifyDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_notifyDate_delta_old" ON "dbrdf_notifyDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_notifyDate_delta_old" ON "dbrdf_notifyDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_notifyDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1346
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_membership_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_membership_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_membership" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_membership_delta_old" ON "dbrdf_membership_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_membership_delta_old" ON "dbrdf_membership_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_membership_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1347
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_buriedPlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_buriedPlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_buriedPlace" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_buriedPlace_delta_old" ON "dbrdf_buriedPlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_buriedPlace_delta_old" ON "dbrdf_buriedPlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_buriedPlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1348
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cargoWater_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cargoWater_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_cargoWater0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cargoWater_delta_old0" ON "dbrdf_cargoWater_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_cargoWater_delta_old0" ON "dbrdf_cargoWater_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cargoWater_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_cargoWater0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cargoWater_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_cargoWater_delta_old0";
        INSERT INTO "dbrdf_cargoWater_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cargoWater_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_cargoWater_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1349
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Model"(s) SELECT DISTINCT t0.s FROM "dbrdf_Model_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Model_delta_old";
        INSERT INTO "dbrdf_Model_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Model_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Model_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1350
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_layingDown_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_layingDown_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_layingDown" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_layingDown_delta_old" ON "dbrdf_layingDown_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_layingDown_delta_old" ON "dbrdf_layingDown_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_layingDown_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1351
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1352
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_oldcode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_oldcode_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_oldcode" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_oldcode_delta_old" ON "dbrdf_oldcode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_oldcode_delta_old" ON "dbrdf_oldcode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_oldcode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1353
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_stationStructure_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_stationStructure_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_stationStructure" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_stationStructure_delta_old" ON "dbrdf_stationStructure_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_stationStructure_delta_old" ON "dbrdf_stationStructure_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_stationStructure_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1354
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_purpose_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_purpose_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_purpose" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_purpose_delta_old" ON "dbrdf_purpose_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_purpose_delta_old" ON "dbrdf_purpose_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_purpose_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1355
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstDriverTeam_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstDriverTeam_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_firstDriverTeam" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstDriverTeam_delta_old" ON "dbrdf_firstDriverTeam_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstDriverTeam_delta_old" ON "dbrdf_firstDriverTeam_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstDriverTeam_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1356
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_brainInfoType_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_brainInfoType_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_brainInfoType" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_brainInfoType_delta_old" ON "dbrdf_brainInfoType_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_brainInfoType_delta_old" ON "dbrdf_brainInfoType_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_brainInfoType_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1357
    ---- DEPENDS ON: 1356, 1322, 1269, 817, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Brain>(?X) :- <http://dbpedia.org/ontology/component>(?X,?X1) .
    INSERT INTO "dbrdf_Brain"(s) SELECT DISTINCT t0.s FROM "dbrdf_component" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Brain" 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_Brain_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Brain_delta_old"(s) SELECT t0.s FROM "dbrdf_Brain" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Brain_delta_old" ON "dbrdf_Brain_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Brain_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/Brain$delta_new>(?Y) :- <http://dbpedia.org/ontology/Brain$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Brain_delta_new"(s) SELECT t1.o FROM "dbrdf_Brain_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Brain" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Brain"(s) SELECT DISTINCT t0.s FROM "dbrdf_Brain_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Brain_delta_old";
        INSERT INTO "dbrdf_Brain_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Brain_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Brain_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1358
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_animal_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_animal_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_animal" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_animal_delta_old" ON "dbrdf_animal_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_animal_delta_old" ON "dbrdf_animal_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_animal_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1359
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_academicAdvisor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_academicAdvisor_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_academicAdvisor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_academicAdvisor_delta_old" ON "dbrdf_academicAdvisor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_academicAdvisor_delta_old" ON "dbrdf_academicAdvisor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_academicAdvisor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1360
    ---- DEPENDS ON: 1359, 1285, 1021, 225, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Scientist>(?X) :- <http://dbpedia.org/ontology/doctoralAdvisor>(?X,?X1) .
    INSERT INTO "dbrdf_Scientist"(s) SELECT DISTINCT t0.s FROM "dbrdf_doctoralAdvisor" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Scientist" 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_Scientist_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Scientist_delta_old"(s) SELECT t0.s FROM "dbrdf_Scientist" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Scientist_delta_old" ON "dbrdf_Scientist_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Scientist_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/Scientist$delta_new>(?Y) :- <http://dbpedia.org/ontology/Scientist$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Scientist_delta_new"(s) SELECT t1.o FROM "dbrdf_Scientist_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Scientist" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Scientist"(s) SELECT DISTINCT t0.s FROM "dbrdf_Scientist_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Scientist_delta_old";
        INSERT INTO "dbrdf_Scientist_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Scientist_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Scientist_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1361
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_VoiceActor"(s) SELECT DISTINCT t0.s FROM "dbrdf_VoiceActor_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_VoiceActor_delta_old";
        INSERT INTO "dbrdf_VoiceActor_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_VoiceActor_delta_new" t0;
        TRUNCATE TABLE "dbrdf_VoiceActor_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1362
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_detectionMethod_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_detectionMethod_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_detectionMethod" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_detectionMethod_delta_old" ON "dbrdf_detectionMethod_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_detectionMethod_delta_old" ON "dbrdf_detectionMethod_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_detectionMethod_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1363
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtProTournaments_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtProTournaments_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_winsAtProTournaments" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtProTournaments_delta_old" ON "dbrdf_winsAtProTournaments_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtProTournaments_delta_old" ON "dbrdf_winsAtProTournaments_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtProTournaments_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1364
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_PokerPlayer"(s) SELECT DISTINCT t0.s FROM "dbrdf_PokerPlayer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_PokerPlayer_delta_old";
        INSERT INTO "dbrdf_PokerPlayer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_PokerPlayer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_PokerPlayer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1365
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_productionEndDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_productionEndDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_productionEndDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_productionEndDate_delta_old" ON "dbrdf_productionEndDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_productionEndDate_delta_old" ON "dbrdf_productionEndDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_productionEndDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1366
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_careerPrizeMoney_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_careerPrizeMoney_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_careerPrizeMoney" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_careerPrizeMoney_delta_old" ON "dbrdf_careerPrizeMoney_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_careerPrizeMoney_delta_old" ON "dbrdf_careerPrizeMoney_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_careerPrizeMoney_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1367
    ---- DEPENDS ON: 1366, 1205, 1100, 410, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/TennisPlayer>(?X) :- <http://dbpedia.org/ontology/rankingsSingles>(?X,?X1) .
    INSERT INTO "dbrdf_TennisPlayer"(s) SELECT DISTINCT t0.s FROM "dbrdf_rankingsSingles" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_TennisPlayer" 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_TennisPlayer_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_TennisPlayer_delta_old"(s) SELECT t0.s FROM "dbrdf_TennisPlayer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_TennisPlayer_delta_old" ON "dbrdf_TennisPlayer_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_TennisPlayer_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/TennisPlayer$delta_new>(?Y) :- <http://dbpedia.org/ontology/TennisPlayer$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_TennisPlayer_delta_new"(s) SELECT t1.o FROM "dbrdf_TennisPlayer_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_TennisPlayer" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_TennisPlayer"(s) SELECT DISTINCT t0.s FROM "dbrdf_TennisPlayer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_TennisPlayer_delta_old";
        INSERT INTO "dbrdf_TennisPlayer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_TennisPlayer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_TennisPlayer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1368
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_complexion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_complexion_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_complexion" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_complexion_delta_old" ON "dbrdf_complexion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_complexion_delta_old" ON "dbrdf_complexion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_complexion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1369
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_inflow_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_inflow_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_inflow" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_inflow_delta_old" ON "dbrdf_inflow_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_inflow_delta_old" ON "dbrdf_inflow_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_inflow_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1370
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_speaker_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_speaker_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_speaker" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_speaker_delta_old" ON "dbrdf_speaker_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_speaker_delta_old" ON "dbrdf_speaker_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_speaker_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1371
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_distance1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_distance_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_distance_delta_old1";
        INSERT INTO "dbrdf_distance_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_distance_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_distance_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1372
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_position_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_position_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_position" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_position_delta_old" ON "dbrdf_position_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_position_delta_old" ON "dbrdf_position_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_position_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1373
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_eyeColor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_eyeColor_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_eyeColor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_eyeColor_delta_old" ON "dbrdf_eyeColor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_eyeColor_delta_old" ON "dbrdf_eyeColor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_eyeColor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1374
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_climate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_climate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_climate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_climate_delta_old" ON "dbrdf_climate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_climate_delta_old" ON "dbrdf_climate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_climate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1375
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_hometown_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_hometown_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_hometown" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_hometown_delta_old" ON "dbrdf_hometown_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_hometown_delta_old" ON "dbrdf_hometown_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_hometown_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1376
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceConfluenceCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sourceConfluenceCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_sourceConfluenceCountry" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sourceConfluenceCountry_delta_old" ON "dbrdf_sourceConfluenceCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sourceConfluenceCountry_delta_old" ON "dbrdf_sourceConfluenceCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceConfluenceCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1377
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_CanadianFootballLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_CanadianFootballLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_CanadianFootballLeague_delta_old";
        INSERT INTO "dbrdf_CanadianFootballLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_CanadianFootballLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_CanadianFootballLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1378
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_length_delta_old3"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_length_delta_old3"(s, o) SELECT t0.s, t0.o FROM "dbrdf_length3" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_length_delta_old3" ON "dbrdf_length_delta_old3"(s, o); CREATE INDEX "IDX_1_dbrdf_length_delta_old3" ON "dbrdf_length_delta_old3"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_length_delta_new3"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1379
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1380
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dcc_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dcc_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_dcc" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dcc_delta_old" ON "dbrdf_dcc_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dcc_delta_old" ON "dbrdf_dcc_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dcc_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1381
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_torchBearer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_torchBearer_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_torchBearer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_torchBearer_delta_old" ON "dbrdf_torchBearer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_torchBearer_delta_old" ON "dbrdf_torchBearer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_torchBearer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1382
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_engineer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_engineer_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_engineer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_engineer_delta_old" ON "dbrdf_engineer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_engineer_delta_old" ON "dbrdf_engineer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_engineer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1383
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_vicePrincipal_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_vicePrincipal_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_vicePrincipal" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_vicePrincipal_delta_old" ON "dbrdf_vicePrincipal_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_vicePrincipal_delta_old" ON "dbrdf_vicePrincipal_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_vicePrincipal_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1384
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_soccerTournamentThisSeason_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_soccerTournamentThisSeason_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_soccerTournamentThisSeason" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_soccerTournamentThisSeason_delta_old" ON "dbrdf_soccerTournamentThisSeason_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_soccerTournamentThisSeason_delta_old" ON "dbrdf_soccerTournamentThisSeason_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_soccerTournamentThisSeason_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1385
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rankInFinalMedalCount_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rankInFinalMedalCount_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_rankInFinalMedalCount" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rankInFinalMedalCount_delta_old" ON "dbrdf_rankInFinalMedalCount_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rankInFinalMedalCount_delta_old" ON "dbrdf_rankInFinalMedalCount_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rankInFinalMedalCount_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1386
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_film_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_film_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_film" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_film_delta_old" ON "dbrdf_film_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_film_delta_old" ON "dbrdf_film_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_film_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1387
    ---- DEPENDS ON: 1386, 925, 298, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

    -- [Rule] <http://dbpedia.org/ontology/FilmFestival>(?X) :- <http://dbpedia.org/ontology/film>(?X,?X1) .
    INSERT INTO "dbrdf_FilmFestival"(s) SELECT DISTINCT t0.s FROM "dbrdf_film" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_FilmFestival" 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_FilmFestival_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_FilmFestival_delta_old"(s) SELECT t0.s FROM "dbrdf_FilmFestival" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_FilmFestival_delta_old" ON "dbrdf_FilmFestival_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_FilmFestival_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/FilmFestival$delta_new>(?Y) :- <http://dbpedia.org/ontology/FilmFestival$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_FilmFestival_delta_new"(s) SELECT t1.o FROM "dbrdf_FilmFestival_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_FilmFestival" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_FilmFestival"(s) SELECT DISTINCT t0.s FROM "dbrdf_FilmFestival_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_FilmFestival_delta_old";
        INSERT INTO "dbrdf_FilmFestival_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_FilmFestival_delta_new" t0;
        TRUNCATE TABLE "dbrdf_FilmFestival_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1388
    ---- DEPENDS ON: 1387, 624, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- [Rule] <http://schema.org/Festival>(?X) :- <http://dbpedia.org/ontology/FilmFestival>(?X) .
    INSERT INTO "dbrdf_Festival"(s) SELECT t0.s FROM "dbrdf_FilmFestival" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Festival" 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_Festival_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Festival_delta_old"(s) SELECT t0.s FROM "dbrdf_Festival" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Festival_delta_old" ON "dbrdf_Festival_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Festival_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Festival"(s) SELECT DISTINCT t0.s FROM "dbrdf_Festival_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Festival_delta_old";
        INSERT INTO "dbrdf_Festival_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Festival_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Festival_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1389
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_absoluteMagnitude_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_absoluteMagnitude_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_absoluteMagnitude" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_absoluteMagnitude_delta_old" ON "dbrdf_absoluteMagnitude_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_absoluteMagnitude_delta_old" ON "dbrdf_absoluteMagnitude_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_absoluteMagnitude_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1390
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1391
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_chairmanTitle_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_chairmanTitle_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_chairmanTitle" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_chairmanTitle_delta_old" ON "dbrdf_chairmanTitle_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_chairmanTitle_delta_old" ON "dbrdf_chairmanTitle_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_chairmanTitle_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1392
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_squadNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_squadNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_squadNumber" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_squadNumber_delta_old" ON "dbrdf_squadNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_squadNumber_delta_old" ON "dbrdf_squadNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_squadNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1393
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_domain_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_domain_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_domain" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_domain_delta_old" ON "dbrdf_domain_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_domain_delta_old" ON "dbrdf_domain_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_domain_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1394
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_totalTracks_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_totalTracks_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_totalTracks" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_totalTracks_delta_old" ON "dbrdf_totalTracks_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_totalTracks_delta_old" ON "dbrdf_totalTracks_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_totalTracks_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1395
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_richestCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_richestCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_richestCountry" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_richestCountry_delta_old" ON "dbrdf_richestCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_richestCountry_delta_old" ON "dbrdf_richestCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_richestCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1396
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_shipDraft_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_shipDraft_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_shipDraft" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_shipDraft_delta_old" ON "dbrdf_shipDraft_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_shipDraft_delta_old" ON "dbrdf_shipDraft_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_shipDraft_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1397
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_missionDuration0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_missionDuration_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_missionDuration_delta_old0";
        INSERT INTO "dbrdf_missionDuration_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_missionDuration_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_missionDuration_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1398
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rgbCoordinateBlue_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rgbCoordinateBlue_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_rgbCoordinateBlue" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rgbCoordinateBlue_delta_old" ON "dbrdf_rgbCoordinateBlue_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rgbCoordinateBlue_delta_old" ON "dbrdf_rgbCoordinateBlue_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rgbCoordinateBlue_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1399
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_diameter_delta_old2"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_diameter_delta_old2"(s, o) SELECT t0.s, t0.o FROM "dbrdf_diameter2" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_diameter_delta_old2" ON "dbrdf_diameter_delta_old2"(s, o); CREATE INDEX "IDX_1_dbrdf_diameter_delta_old2" ON "dbrdf_diameter_delta_old2"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_diameter_delta_new2"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1400
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_neighbourConstellations_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_neighbourConstellations_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_neighbourConstellations" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_neighbourConstellations_delta_old" ON "dbrdf_neighbourConstellations_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_neighbourConstellations_delta_old" ON "dbrdf_neighbourConstellations_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_neighbourConstellations_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1401
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1402
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumInclination_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_maximumInclination_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_maximumInclination" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_maximumInclination_delta_old" ON "dbrdf_maximumInclination_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_maximumInclination_delta_old" ON "dbrdf_maximumInclination_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumInclination_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1403
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_meetingRoad_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_meetingRoad_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_meetingRoad" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_meetingRoad_delta_old" ON "dbrdf_meetingRoad_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_meetingRoad_delta_old" ON "dbrdf_meetingRoad_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_meetingRoad_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1404
    ---- DEPENDS ON: 1403, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/RoadJunction>(?X) :- <http://dbpedia.org/ontology/meetingRoad>(?X,?X1) .
    INSERT INTO "dbrdf_RoadJunction"(s) SELECT DISTINCT t0.s FROM "dbrdf_meetingRoad" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_RoadJunction" 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_RoadJunction_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_RoadJunction_delta_old"(s) SELECT t0.s FROM "dbrdf_RoadJunction" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_RoadJunction_delta_old" ON "dbrdf_RoadJunction_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_RoadJunction_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/RoadJunction$delta_new>(?Y) :- <http://dbpedia.org/ontology/RoadJunction$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_RoadJunction_delta_new"(s) SELECT t1.o FROM "dbrdf_RoadJunction_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_RoadJunction" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_RoadJunction"(s) SELECT DISTINCT t0.s FROM "dbrdf_RoadJunction_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_RoadJunction_delta_old";
        INSERT INTO "dbrdf_RoadJunction_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_RoadJunction_delta_new" t0;
        TRUNCATE TABLE "dbrdf_RoadJunction_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1405
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_specialEffects_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_specialEffects_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_specialEffects" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_specialEffects_delta_old" ON "dbrdf_specialEffects_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_specialEffects_delta_old" ON "dbrdf_specialEffects_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_specialEffects_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1406
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_soccerTournamentLastChampion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_soccerTournamentLastChampion_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_soccerTournamentLastChampion" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_soccerTournamentLastChampion_delta_old" ON "dbrdf_soccerTournamentLastChampion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_soccerTournamentLastChampion_delta_old" ON "dbrdf_soccerTournamentLastChampion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_soccerTournamentLastChampion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1407
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_parent_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_parent_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_parent" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_parent_delta_old" ON "dbrdf_parent_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_parent_delta_old" ON "dbrdf_parent_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_parent_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1408
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_areaMetro1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_areaMetro_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_areaMetro_delta_old1";
        INSERT INTO "dbrdf_areaMetro_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_areaMetro_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_areaMetro_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1409
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mayor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mayor_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_mayor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mayor_delta_old" ON "dbrdf_mayor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mayor_delta_old" ON "dbrdf_mayor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mayor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1410
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_highestRank_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_highestRank_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_highestRank" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_highestRank_delta_old" ON "dbrdf_highestRank_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_highestRank_delta_old" ON "dbrdf_highestRank_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_highestRank_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1411
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_electionDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_electionDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_electionDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_electionDate_delta_old" ON "dbrdf_electionDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_electionDate_delta_old" ON "dbrdf_electionDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_electionDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1412
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstDriverCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstDriverCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_firstDriverCountry" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstDriverCountry_delta_old" ON "dbrdf_firstDriverCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstDriverCountry_delta_old" ON "dbrdf_firstDriverCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstDriverCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1413
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dissolutionYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dissolutionYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_dissolutionYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dissolutionYear_delta_old" ON "dbrdf_dissolutionYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dissolutionYear_delta_old" ON "dbrdf_dissolutionYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dissolutionYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1414
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_orbitalFlights_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_orbitalFlights_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_orbitalFlights" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_orbitalFlights_delta_old" ON "dbrdf_orbitalFlights_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_orbitalFlights_delta_old" ON "dbrdf_orbitalFlights_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_orbitalFlights_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1415
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastLaunchDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lastLaunchDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lastLaunchDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lastLaunchDate_delta_old" ON "dbrdf_lastLaunchDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lastLaunchDate_delta_old" ON "dbrdf_lastLaunchDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastLaunchDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1416
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_creativeDirector_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_creativeDirector_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_creativeDirector" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_creativeDirector_delta_old" ON "dbrdf_creativeDirector_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_creativeDirector_delta_old" ON "dbrdf_creativeDirector_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_creativeDirector_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1417
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_gun_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_gun_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_gun" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_gun_delta_old" ON "dbrdf_gun_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_gun_delta_old" ON "dbrdf_gun_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_gun_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1418
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_fundedBy_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_fundedBy_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_fundedBy" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_fundedBy_delta_old" ON "dbrdf_fundedBy_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_fundedBy_delta_old" ON "dbrdf_fundedBy_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_fundedBy_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1419
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_priceMoney_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_priceMoney_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_priceMoney" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_priceMoney_delta_old" ON "dbrdf_priceMoney_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_priceMoney_delta_old" ON "dbrdf_priceMoney_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_priceMoney_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1420
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mostPopulatedCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mostPopulatedCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_mostPopulatedCountry" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mostPopulatedCountry_delta_old" ON "dbrdf_mostPopulatedCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mostPopulatedCountry_delta_old" ON "dbrdf_mostPopulatedCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mostPopulatedCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1421
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_regionalLanguage_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_regionalLanguage_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_regionalLanguage" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_regionalLanguage_delta_old" ON "dbrdf_regionalLanguage_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_regionalLanguage_delta_old" ON "dbrdf_regionalLanguage_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_regionalLanguage_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1422
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_launch_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_launch_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_launch" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_launch_delta_old" ON "dbrdf_launch_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_launch_delta_old" ON "dbrdf_launch_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_launch_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1423
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_largestCity_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_largestCity_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_largestCity" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_largestCity_delta_old" ON "dbrdf_largestCity_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_largestCity_delta_old" ON "dbrdf_largestCity_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_largestCity_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1424
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_programmeFormat_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_programmeFormat_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_programmeFormat" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_programmeFormat_delta_old" ON "dbrdf_programmeFormat_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_programmeFormat_delta_old" ON "dbrdf_programmeFormat_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_programmeFormat_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1425
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_denomination_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_denomination_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_denomination" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_denomination_delta_old" ON "dbrdf_denomination_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_denomination_delta_old" ON "dbrdf_denomination_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_denomination_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1426
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ecNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ecNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_ecNumber" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ecNumber_delta_old" ON "dbrdf_ecNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ecNumber_delta_old" ON "dbrdf_ecNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ecNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1427
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dorlandsSuffix_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dorlandsSuffix_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_dorlandsSuffix" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dorlandsSuffix_delta_old" ON "dbrdf_dorlandsSuffix_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dorlandsSuffix_delta_old" ON "dbrdf_dorlandsSuffix_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dorlandsSuffix_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1428
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_demolitionDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_demolitionDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_demolitionDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_demolitionDate_delta_old" ON "dbrdf_demolitionDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_demolitionDate_delta_old" ON "dbrdf_demolitionDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_demolitionDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1429
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dateClosed_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dateClosed_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_dateClosed" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dateClosed_delta_old" ON "dbrdf_dateClosed_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dateClosed_delta_old" ON "dbrdf_dateClosed_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dateClosed_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1430
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1431
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1432
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1433
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1434
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1435
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1436
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1437
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1438
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_viceLeaderParty_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_viceLeaderParty_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_viceLeaderParty" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_viceLeaderParty_delta_old" ON "dbrdf_viceLeaderParty_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_viceLeaderParty_delta_old" ON "dbrdf_viceLeaderParty_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_viceLeaderParty_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1439
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfMunicipalities_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfMunicipalities_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfMunicipalities" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfMunicipalities_delta_old" ON "dbrdf_numberOfMunicipalities_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfMunicipalities_delta_old" ON "dbrdf_numberOfMunicipalities_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfMunicipalities_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1440
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1441
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1442
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1443
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_emedicineSubject_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_emedicineSubject_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_emedicineSubject" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_emedicineSubject_delta_old" ON "dbrdf_emedicineSubject_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_emedicineSubject_delta_old" ON "dbrdf_emedicineSubject_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_emedicineSubject_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1444
    ---- DEPENDS ON: 1443, 1177, 1173, 1095, 1043, 754, 679, 164, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Disease>(?X) :- <http://dbpedia.org/ontology/icd9>(?X,?X1) .
    INSERT INTO "dbrdf_Disease"(s) SELECT DISTINCT t0.s FROM "dbrdf_icd9" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Disease" 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_Disease_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Disease_delta_old"(s) SELECT t0.s FROM "dbrdf_Disease" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Disease_delta_old" ON "dbrdf_Disease_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Disease_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/Disease$delta_new>(?Y) :- <http://dbpedia.org/ontology/Disease$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Disease_delta_new"(s) SELECT t1.o FROM "dbrdf_Disease_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Disease" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Disease"(s) SELECT DISTINCT t0.s FROM "dbrdf_Disease_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Disease_delta_old";
        INSERT INTO "dbrdf_Disease_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Disease_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Disease_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1445
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1446
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1447
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_satellitesDeployed_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_satellitesDeployed_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_satellitesDeployed" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_satellitesDeployed_delta_old" ON "dbrdf_satellitesDeployed_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_satellitesDeployed_delta_old" ON "dbrdf_satellitesDeployed_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_satellitesDeployed_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1448
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1449
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Mollusca_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Mollusca_delta_old"(s) SELECT t0.s FROM "dbrdf_Mollusca" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Mollusca_delta_old" ON "dbrdf_Mollusca_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Mollusca_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Mollusca"(s) SELECT DISTINCT t0.s FROM "dbrdf_Mollusca_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Mollusca_delta_old";
        INSERT INTO "dbrdf_Mollusca_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Mollusca_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Mollusca_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1450
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Bone_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Bone_delta_old"(s) SELECT t0.s FROM "dbrdf_Bone" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Bone_delta_old" ON "dbrdf_Bone_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Bone_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Bone"(s) SELECT DISTINCT t0.s FROM "dbrdf_Bone_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Bone_delta_old";
        INSERT INTO "dbrdf_Bone_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Bone_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Bone_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1451
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_startYearOfSales_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_startYearOfSales_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_startYearOfSales" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_startYearOfSales_delta_old" ON "dbrdf_startYearOfSales_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_startYearOfSales_delta_old" ON "dbrdf_startYearOfSales_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_startYearOfSales_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1452
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_BoxingLeague_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_BoxingLeague_delta_old"(s) SELECT t0.s FROM "dbrdf_BoxingLeague" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_BoxingLeague_delta_old" ON "dbrdf_BoxingLeague_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_BoxingLeague_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_BoxingLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_BoxingLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_BoxingLeague_delta_old";
        INSERT INTO "dbrdf_BoxingLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_BoxingLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_BoxingLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1453
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_startYearOfInsertion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_startYearOfInsertion_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_startYearOfInsertion" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_startYearOfInsertion_delta_old" ON "dbrdf_startYearOfInsertion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_startYearOfInsertion_delta_old" ON "dbrdf_startYearOfInsertion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_startYearOfInsertion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1454
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1455
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1456
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftAttack_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftAttack_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_aircraftAttack" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftAttack_delta_old" ON "dbrdf_aircraftAttack_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftAttack_delta_old" ON "dbrdf_aircraftAttack_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftAttack_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1457
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1458
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1459
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1460
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1461
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1462
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1463
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1464
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_CyclingLeague_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_CyclingLeague_delta_old"(s) SELECT t0.s FROM "dbrdf_CyclingLeague" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_CyclingLeague_delta_old" ON "dbrdf_CyclingLeague_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_CyclingLeague_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_CyclingLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_CyclingLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_CyclingLeague_delta_old";
        INSERT INTO "dbrdf_CyclingLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_CyclingLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_CyclingLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1465
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1466
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1467
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1468
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1469
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1470
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Crustacean_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Crustacean_delta_old"(s) SELECT t0.s FROM "dbrdf_Crustacean" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Crustacean_delta_old" ON "dbrdf_Crustacean_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Crustacean_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Crustacean"(s) SELECT DISTINCT t0.s FROM "dbrdf_Crustacean_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Crustacean_delta_old";
        INSERT INTO "dbrdf_Crustacean_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Crustacean_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Crustacean_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1471
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1472
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1473
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1474
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1475
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1476
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_slogan_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_slogan_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_slogan" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_slogan_delta_old" ON "dbrdf_slogan_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_slogan_delta_old" ON "dbrdf_slogan_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_slogan_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1477
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1478
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1479
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1480
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_AustralianFootballLeague_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_AustralianFootballLeague_delta_old"(s) SELECT t0.s FROM "dbrdf_AustralianFootballLeague" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_AustralianFootballLeague_delta_old" ON "dbrdf_AustralianFootballLeague_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_AustralianFootballLeague_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_AustralianFootballLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_AustralianFootballLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_AustralianFootballLeague_delta_old";
        INSERT INTO "dbrdf_AustralianFootballLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_AustralianFootballLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_AustralianFootballLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1481
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1482
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1483
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_crownDependency_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_crownDependency_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_crownDependency" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_crownDependency_delta_old" ON "dbrdf_crownDependency_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_crownDependency_delta_old" ON "dbrdf_crownDependency_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_crownDependency_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1484
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1485
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1486
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1487
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1488
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1489
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1490
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1491
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_previousMission_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_previousMission_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_previousMission" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_previousMission_delta_old" ON "dbrdf_previousMission_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_previousMission_delta_old" ON "dbrdf_previousMission_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_previousMission_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1492
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1493
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_statisticValue_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_statisticValue_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_statisticValue" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_statisticValue_delta_old" ON "dbrdf_statisticValue_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_statisticValue_delta_old" ON "dbrdf_statisticValue_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_statisticValue_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1494
    ---- DEPENDS ON: 1493, 1338, 613, 112, 76, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/BaseballPlayer>(?X) :- <http://dbpedia.org/ontology/throwingSide>(?X,?X1) .
    INSERT INTO "dbrdf_BaseballPlayer"(s) SELECT DISTINCT t0.s FROM "dbrdf_throwingSide" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_BaseballPlayer" 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_BaseballPlayer_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_BaseballPlayer_delta_old"(s) SELECT t0.s FROM "dbrdf_BaseballPlayer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_BaseballPlayer_delta_old" ON "dbrdf_BaseballPlayer_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_BaseballPlayer_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/BaseballPlayer$delta_new>(?Y) :- <http://dbpedia.org/ontology/BaseballPlayer$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_BaseballPlayer_delta_new"(s) SELECT t1.o FROM "dbrdf_BaseballPlayer_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_BaseballPlayer" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_BaseballPlayer"(s) SELECT DISTINCT t0.s FROM "dbrdf_BaseballPlayer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_BaseballPlayer_delta_old";
        INSERT INTO "dbrdf_BaseballPlayer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_BaseballPlayer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_BaseballPlayer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1495
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1496
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_isHandicappedAccessible_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_isHandicappedAccessible_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_isHandicappedAccessible" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_isHandicappedAccessible_delta_old" ON "dbrdf_isHandicappedAccessible_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_isHandicappedAccessible_delta_old" ON "dbrdf_isHandicappedAccessible_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_isHandicappedAccessible_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1497
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1498
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ShoppingCenter_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ShoppingCenter_delta_old"(s) SELECT t0.s FROM "dbrdf_ShoppingCenter" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ShoppingCenter_delta_old" ON "dbrdf_ShoppingCenter_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ShoppingCenter_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ShoppingMall_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ShoppingMall_delta_old"(s) SELECT t0.s FROM "dbrdf_ShoppingMall" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ShoppingMall_delta_old" ON "dbrdf_ShoppingMall_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ShoppingMall_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://schema.org/ShoppingCenter$delta_new>(?X) :- <http://dbpedia.org/ontology/ShoppingMall$delta_old>(?X) .
        INSERT INTO "dbrdf_ShoppingCenter_delta_new"(s) SELECT t0.s FROM "dbrdf_ShoppingMall_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_ShoppingCenter" ex WHERE ex.s = t0.s);


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


        -- <http://dbpedia.org/ontology/ShoppingMall$delta_new>(?X) :- <http://schema.org/ShoppingCenter$delta_old>(?X) .
        INSERT INTO "dbrdf_ShoppingMall_delta_new"(s) SELECT t0.s FROM "dbrdf_ShoppingCenter_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_ShoppingMall" ex WHERE ex.s = t0.s);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_ShoppingCenter"(s) SELECT DISTINCT t0.s FROM "dbrdf_ShoppingCenter_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_ShoppingCenter_delta_old";
        INSERT INTO "dbrdf_ShoppingCenter_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_ShoppingCenter_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ShoppingCenter_delta_new";

        INSERT INTO "dbrdf_ShoppingMall"(s) SELECT DISTINCT t0.s FROM "dbrdf_ShoppingMall_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_ShoppingMall_delta_old";
        INSERT INTO "dbrdf_ShoppingMall_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_ShoppingMall_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ShoppingMall_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1499
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1500
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_AutoRacingLeague_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_AutoRacingLeague_delta_old"(s) SELECT t0.s FROM "dbrdf_AutoRacingLeague" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_AutoRacingLeague_delta_old" ON "dbrdf_AutoRacingLeague_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_AutoRacingLeague_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_AutoRacingLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_AutoRacingLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_AutoRacingLeague_delta_old";
        INSERT INTO "dbrdf_AutoRacingLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_AutoRacingLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_AutoRacingLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1501
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1502
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_maximumTemperature0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_maximumTemperature_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_maximumTemperature_delta_old0";
        INSERT INTO "dbrdf_maximumTemperature_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_maximumTemperature_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_maximumTemperature_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1503
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1504
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1505
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_CanadianFootballPlayer_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_CanadianFootballPlayer_delta_old"(s) SELECT t0.s FROM "dbrdf_CanadianFootballPlayer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_CanadianFootballPlayer_delta_old" ON "dbrdf_CanadianFootballPlayer_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_CanadianFootballPlayer_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_CanadianFootballPlayer"(s) SELECT DISTINCT t0.s FROM "dbrdf_CanadianFootballPlayer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_CanadianFootballPlayer_delta_old";
        INSERT INTO "dbrdf_CanadianFootballPlayer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_CanadianFootballPlayer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_CanadianFootballPlayer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1506
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1507
    ---- DEPENDS ON: 1506, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/OfficeHolder>(?X) :- <http://dbpedia.org/ontology/otherParty>(?X,?X1) .
    INSERT INTO "dbrdf_OfficeHolder"(s) SELECT DISTINCT t0.s FROM "dbrdf_otherParty" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_OfficeHolder" 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_OfficeHolder_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_OfficeHolder_delta_old"(s) SELECT t0.s FROM "dbrdf_OfficeHolder" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_OfficeHolder_delta_old" ON "dbrdf_OfficeHolder_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_OfficeHolder_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_OfficeHolder"(s) SELECT DISTINCT t0.s FROM "dbrdf_OfficeHolder_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_OfficeHolder_delta_old";
        INSERT INTO "dbrdf_OfficeHolder_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_OfficeHolder_delta_new" t0;
        TRUNCATE TABLE "dbrdf_OfficeHolder_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1508
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaOfCatchment_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_areaOfCatchment_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_areaOfCatchment0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_areaOfCatchment_delta_old0" ON "dbrdf_areaOfCatchment_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_areaOfCatchment_delta_old0" ON "dbrdf_areaOfCatchment_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaOfCatchment_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- <http://dbpedia.org/ontology/areaOfCatchment$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/areaOfCatchment$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
