        INSERT INTO "dbrdf_wineRegion_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_wineRegion_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_wineRegion" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 662
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rocket_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rocket_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_rocket" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rocket_delta_old" ON "dbrdf_rocket_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rocket_delta_old" ON "dbrdf_rocket_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rocket_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 663
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_secondDriverCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_secondDriverCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_secondDriverCountry" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_secondDriverCountry_delta_old" ON "dbrdf_secondDriverCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_secondDriverCountry_delta_old" ON "dbrdf_secondDriverCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_secondDriverCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 664
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 665
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_port2DockedTime_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_port2DockedTime_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_port2DockedTime" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_port2DockedTime_delta_old" ON "dbrdf_port2DockedTime_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_port2DockedTime_delta_old" ON "dbrdf_port2DockedTime_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_port2DockedTime_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 666
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lowestState_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lowestState_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lowestState" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lowestState_delta_old" ON "dbrdf_lowestState_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lowestState_delta_old" ON "dbrdf_lowestState_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lowestState_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 667
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_VideogamesLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_VideogamesLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_VideogamesLeague_delta_old";
        INSERT INTO "dbrdf_VideogamesLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_VideogamesLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_VideogamesLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 668
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nationalFilmAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nationalFilmAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_nationalFilmAward" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nationalFilmAward_delta_old" ON "dbrdf_nationalFilmAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nationalFilmAward_delta_old" ON "dbrdf_nationalFilmAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nationalFilmAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 669
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_fees_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_fees_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_fees" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_fees_delta_old" ON "dbrdf_fees_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_fees_delta_old" ON "dbrdf_fees_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_fees_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 670
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_discovered_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_discovered_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_discovered" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_discovered_delta_old" ON "dbrdf_discovered_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_discovered_delta_old" ON "dbrdf_discovered_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_discovered_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 671
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_academyAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_academyAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_academyAward" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_academyAward_delta_old" ON "dbrdf_academyAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_academyAward_delta_old" ON "dbrdf_academyAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_academyAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 672
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_coronationDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_coronationDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_coronationDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_coronationDate_delta_old" ON "dbrdf_coronationDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_coronationDate_delta_old" ON "dbrdf_coronationDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_coronationDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 673
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Continent_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Continent_delta_old"(s) SELECT t0.s FROM "dbrdf_Continent" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Continent_delta_old" ON "dbrdf_Continent_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Continent_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Continent_delta_old0"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Continent_delta_old0"(s) SELECT t0.s FROM "dbrdf_Continent0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Continent_delta_old0" ON "dbrdf_Continent_delta_old0"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Continent_delta_new0"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Continent"(s) SELECT DISTINCT t0.s FROM "dbrdf_Continent_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Continent_delta_old";
        INSERT INTO "dbrdf_Continent_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Continent_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Continent_delta_new";

        INSERT INTO "dbrdf_Continent0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Continent_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_Continent_delta_old0";
        INSERT INTO "dbrdf_Continent_delta_old0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Continent_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_Continent_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 674
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_oilSystem_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_oilSystem_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_oilSystem" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_oilSystem_delta_old" ON "dbrdf_oilSystem_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_oilSystem_delta_old" ON "dbrdf_oilSystem_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_oilSystem_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 675
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_secretaryGeneral_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_secretaryGeneral_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_secretaryGeneral" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_secretaryGeneral_delta_old" ON "dbrdf_secretaryGeneral_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_secretaryGeneral_delta_old" ON "dbrdf_secretaryGeneral_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_secretaryGeneral_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 676
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cylinderBore_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cylinderBore_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_cylinderBore" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cylinderBore_delta_old" ON "dbrdf_cylinderBore_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_cylinderBore_delta_old" ON "dbrdf_cylinderBore_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cylinderBore_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 677
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfLiveAlbums_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfLiveAlbums_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfLiveAlbums" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfLiveAlbums_delta_old" ON "dbrdf_numberOfLiveAlbums_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfLiveAlbums_delta_old" ON "dbrdf_numberOfLiveAlbums_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfLiveAlbums_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 678
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_distanceToDouglas_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_distanceToDouglas_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_distanceToDouglas" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_distanceToDouglas_delta_old" ON "dbrdf_distanceToDouglas_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_distanceToDouglas_delta_old" ON "dbrdf_distanceToDouglas_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_distanceToDouglas_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 679
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_medlineplus_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_medlineplus_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_medlineplus" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_medlineplus_delta_old" ON "dbrdf_medlineplus_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_medlineplus_delta_old" ON "dbrdf_medlineplus_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_medlineplus_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 680
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Game"(s) SELECT DISTINCT t0.s FROM "dbrdf_Game_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Game_delta_old";
        INSERT INTO "dbrdf_Game_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Game_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Game_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 681
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_unknownOutcomes_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_unknownOutcomes_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_unknownOutcomes" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_unknownOutcomes_delta_old" ON "dbrdf_unknownOutcomes_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_unknownOutcomes_delta_old" ON "dbrdf_unknownOutcomes_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_unknownOutcomes_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 682
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_command_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_command_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_command" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_command_delta_old" ON "dbrdf_command_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_command_delta_old" ON "dbrdf_command_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_command_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 683
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 684
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_draftRound_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_draftRound_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_draftRound" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_draftRound_delta_old" ON "dbrdf_draftRound_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_draftRound_delta_old" ON "dbrdf_draftRound_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_draftRound_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 685
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_registration_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_registration_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_registration" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_registration_delta_old" ON "dbrdf_registration_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_registration_delta_old" ON "dbrdf_registration_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_registration_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 686
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_shareOfAudience_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_shareOfAudience_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_shareOfAudience" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_shareOfAudience_delta_old" ON "dbrdf_shareOfAudience_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_shareOfAudience_delta_old" ON "dbrdf_shareOfAudience_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_shareOfAudience_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 687
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_shipDisplacement_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_shipDisplacement_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_shipDisplacement" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_shipDisplacement_delta_old" ON "dbrdf_shipDisplacement_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_shipDisplacement_delta_old" ON "dbrdf_shipDisplacement_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_shipDisplacement_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 688
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_subsequentInfrastructure_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_subsequentInfrastructure_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_subsequentInfrastructure" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_subsequentInfrastructure_delta_old" ON "dbrdf_subsequentInfrastructure_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_subsequentInfrastructure_delta_old" ON "dbrdf_subsequentInfrastructure_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_subsequentInfrastructure_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 689
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_school_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_school_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_school" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_school_delta_old" ON "dbrdf_school_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_school_delta_old" ON "dbrdf_school_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_school_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 690
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_range_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_range_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_range" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_range_delta_old" ON "dbrdf_range_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_range_delta_old" ON "dbrdf_range_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_range_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 691
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_pistonStroke_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_pistonStroke_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_pistonStroke" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_pistonStroke_delta_old" ON "dbrdf_pistonStroke_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_pistonStroke_delta_old" ON "dbrdf_pistonStroke_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_pistonStroke_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 692
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_designCompany_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_designCompany_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_designCompany" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_designCompany_delta_old" ON "dbrdf_designCompany_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_designCompany_delta_old" ON "dbrdf_designCompany_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_designCompany_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 693
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 694
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_operatedBy_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_operatedBy_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_operatedBy" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_operatedBy_delta_old" ON "dbrdf_operatedBy_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_operatedBy_delta_old" ON "dbrdf_operatedBy_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_operatedBy_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 695
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_added_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_added_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_added" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_added_delta_old" ON "dbrdf_added_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_added_delta_old" ON "dbrdf_added_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_added_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 696
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_presenter_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_presenter_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_presenter" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_presenter_delta_old" ON "dbrdf_presenter_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_presenter_delta_old" ON "dbrdf_presenter_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_presenter_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 697
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_settingOfPlay_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_settingOfPlay_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_settingOfPlay" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_settingOfPlay_delta_old" ON "dbrdf_settingOfPlay_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_settingOfPlay_delta_old" ON "dbrdf_settingOfPlay_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_settingOfPlay_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 698
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_port2UndockingDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_port2UndockingDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_port2UndockingDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_port2UndockingDate_delta_old" ON "dbrdf_port2UndockingDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_port2UndockingDate_delta_old" ON "dbrdf_port2UndockingDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_port2UndockingDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 699
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_order_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_order_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_order" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_order_delta_old" ON "dbrdf_order_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_order_delta_old" ON "dbrdf_order_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_order_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 700
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_governmentPlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_governmentPlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_governmentPlace" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_governmentPlace_delta_old" ON "dbrdf_governmentPlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_governmentPlace_delta_old" ON "dbrdf_governmentPlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_governmentPlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 701
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_boiler_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_boiler_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_boiler" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_boiler_delta_old" ON "dbrdf_boiler_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_boiler_delta_old" ON "dbrdf_boiler_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_boiler_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 702
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtMajors_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtMajors_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_winsAtMajors" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtMajors_delta_old" ON "dbrdf_winsAtMajors_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtMajors_delta_old" ON "dbrdf_winsAtMajors_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtMajors_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 703
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ground_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ground_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_ground" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ground_delta_old" ON "dbrdf_ground_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ground_delta_old" ON "dbrdf_ground_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ground_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 704
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_course_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_course_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_course" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_course_delta_old" ON "dbrdf_course_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_course_delta_old" ON "dbrdf_course_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_course_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 705
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_visitorsPerDay_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_visitorsPerDay_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_visitorsPerDay" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_visitorsPerDay_delta_old" ON "dbrdf_visitorsPerDay_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_visitorsPerDay_delta_old" ON "dbrdf_visitorsPerDay_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_visitorsPerDay_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 706
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lyrics_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lyrics_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lyrics" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lyrics_delta_old" ON "dbrdf_lyrics_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lyrics_delta_old" ON "dbrdf_lyrics_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lyrics_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 707
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_noteOnPlaceOfBurial_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_noteOnPlaceOfBurial_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_noteOnPlaceOfBurial" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_noteOnPlaceOfBurial_delta_old" ON "dbrdf_noteOnPlaceOfBurial_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_noteOnPlaceOfBurial_delta_old" ON "dbrdf_noteOnPlaceOfBurial_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_noteOnPlaceOfBurial_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 708
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_show_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_show_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_show" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_show_delta_old" ON "dbrdf_show_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_show_delta_old" ON "dbrdf_show_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_show_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 709
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_binomialAuthority_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_binomialAuthority_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_binomialAuthority" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_binomialAuthority_delta_old" ON "dbrdf_binomialAuthority_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_binomialAuthority_delta_old" ON "dbrdf_binomialAuthority_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_binomialAuthority_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 710
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 711
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_humanDevelopmentIndex_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_humanDevelopmentIndex_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_humanDevelopmentIndex" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_humanDevelopmentIndex_delta_old" ON "dbrdf_humanDevelopmentIndex_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_humanDevelopmentIndex_delta_old" ON "dbrdf_humanDevelopmentIndex_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_humanDevelopmentIndex_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 712
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_targetAirport_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_targetAirport_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_targetAirport" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_targetAirport_delta_old" ON "dbrdf_targetAirport_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_targetAirport_delta_old" ON "dbrdf_targetAirport_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_targetAirport_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 713
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_war_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_war_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_war" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_war_delta_old" ON "dbrdf_war_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_war_delta_old" ON "dbrdf_war_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_war_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 714
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_date_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_date_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_date" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_date_delta_old" ON "dbrdf_date_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_date_delta_old" ON "dbrdf_date_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_date_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 715
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_displacement_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_displacement_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_displacement0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_displacement_delta_old0" ON "dbrdf_displacement_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_displacement_delta_old0" ON "dbrdf_displacement_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_displacement_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_displacement0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_displacement_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_displacement_delta_old0";
        INSERT INTO "dbrdf_displacement_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_displacement_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_displacement_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 716
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_PlayboyPlaymate"(s) SELECT DISTINCT t0.s FROM "dbrdf_PlayboyPlaymate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_PlayboyPlaymate_delta_old";
        INSERT INTO "dbrdf_PlayboyPlaymate_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_PlayboyPlaymate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_PlayboyPlaymate_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 717
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_averageSpeed_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_averageSpeed_delta_old1"(s, o) SELECT t0.s, t0.o FROM "dbrdf_averageSpeed1" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_averageSpeed_delta_old1" ON "dbrdf_averageSpeed_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_averageSpeed_delta_old1" ON "dbrdf_averageSpeed_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_averageSpeed_delta_new1"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_averageSpeed1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_averageSpeed_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_averageSpeed_delta_old1";
        INSERT INTO "dbrdf_averageSpeed_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_averageSpeed_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_averageSpeed_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 718
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_makeupArtist_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_makeupArtist_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_makeupArtist" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_makeupArtist_delta_old" ON "dbrdf_makeupArtist_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_makeupArtist_delta_old" ON "dbrdf_makeupArtist_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_makeupArtist_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 719
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_computingPlatform_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_computingPlatform_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_computingPlatform" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_computingPlatform_delta_old" ON "dbrdf_computingPlatform_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_computingPlatform_delta_old" ON "dbrdf_computingPlatform_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_computingPlatform_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 720
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_house_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_house_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_house" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_house_delta_old" ON "dbrdf_house_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_house_delta_old" ON "dbrdf_house_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_house_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 721
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_twinCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_twinCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_twinCountry" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_twinCountry_delta_old" ON "dbrdf_twinCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_twinCountry_delta_old" ON "dbrdf_twinCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_twinCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 722
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_governmentType_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_governmentType_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_governmentType" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_governmentType_delta_old" ON "dbrdf_governmentType_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_governmentType_delta_old" ON "dbrdf_governmentType_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_governmentType_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 723
    ---- DEPENDS ON: 722, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/GovernmentType>(?X1) :- <http://dbpedia.org/ontology/governmentType>(?X,?X1) .
    INSERT INTO "dbrdf_GovernmentType"(s) SELECT DISTINCT t0.o FROM "dbrdf_governmentType" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_GovernmentType" 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_GovernmentType_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_GovernmentType_delta_old"(s) SELECT t0.s FROM "dbrdf_GovernmentType" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_GovernmentType_delta_old" ON "dbrdf_GovernmentType_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_GovernmentType_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/GovernmentType$delta_new>(?Y) :- <http://dbpedia.org/ontology/GovernmentType$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_GovernmentType_delta_new"(s) SELECT t1.o FROM "dbrdf_GovernmentType_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_GovernmentType" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_GovernmentType"(s) SELECT DISTINCT t0.s FROM "dbrdf_GovernmentType_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_GovernmentType_delta_old";
        INSERT INTO "dbrdf_GovernmentType_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_GovernmentType_delta_new" t0;
        TRUNCATE TABLE "dbrdf_GovernmentType_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 724
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_inclination_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_inclination_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_inclination" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_inclination_delta_old" ON "dbrdf_inclination_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_inclination_delta_old" ON "dbrdf_inclination_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_inclination_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 725
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_phylum_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_phylum_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_phylum" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_phylum_delta_old" ON "dbrdf_phylum_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_phylum_delta_old" ON "dbrdf_phylum_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_phylum_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 726
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_powerOutput_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_powerOutput_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_powerOutput0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_powerOutput_delta_old0" ON "dbrdf_powerOutput_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_powerOutput_delta_old0" ON "dbrdf_powerOutput_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_powerOutput_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_powerOutput0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_powerOutput_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_powerOutput_delta_old0";
        INSERT INTO "dbrdf_powerOutput_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_powerOutput_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_powerOutput_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 727
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_partner_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_partner_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_partner" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_partner_delta_old" ON "dbrdf_partner_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_partner_delta_old" ON "dbrdf_partner_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_partner_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 728
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_homeport_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_homeport_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_homeport" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_homeport_delta_old" ON "dbrdf_homeport_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_homeport_delta_old" ON "dbrdf_homeport_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_homeport_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 729
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cargoWater_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cargoWater_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_cargoWater" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cargoWater_delta_old" ON "dbrdf_cargoWater_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_cargoWater_delta_old" ON "dbrdf_cargoWater_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cargoWater_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 730
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_MartialArtist"(s) SELECT DISTINCT t0.s FROM "dbrdf_MartialArtist_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_MartialArtist_delta_old";
        INSERT INTO "dbrdf_MartialArtist_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_MartialArtist_delta_new" t0;
        TRUNCATE TABLE "dbrdf_MartialArtist_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 731
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_politicalPartyOfLeader_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_politicalPartyOfLeader_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_politicalPartyOfLeader" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_politicalPartyOfLeader_delta_old" ON "dbrdf_politicalPartyOfLeader_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_politicalPartyOfLeader_delta_old" ON "dbrdf_politicalPartyOfLeader_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_politicalPartyOfLeader_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 732
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_spacewalkBegin_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_spacewalkBegin_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_spacewalkBegin" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_spacewalkBegin_delta_old" ON "dbrdf_spacewalkBegin_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_spacewalkBegin_delta_old" ON "dbrdf_spacewalkBegin_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_spacewalkBegin_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 733
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_races_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_races_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_races" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_races_delta_old" ON "dbrdf_races_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_races_delta_old" ON "dbrdf_races_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_races_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 734
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_classification_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_classification_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_classification" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_classification_delta_old" ON "dbrdf_classification_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_classification_delta_old" ON "dbrdf_classification_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_classification_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 735
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_militaryUnit_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_militaryUnit_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_militaryUnit" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_militaryUnit_delta_old" ON "dbrdf_militaryUnit_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_militaryUnit_delta_old" ON "dbrdf_militaryUnit_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_militaryUnit_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 736
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_height2"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_height_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_height_delta_old2";
        INSERT INTO "dbrdf_height_delta_old2"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_height_delta_new2" t0;
        TRUNCATE TABLE "dbrdf_height_delta_new2";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 737
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_motto_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_motto_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_motto" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_motto_delta_old" ON "dbrdf_motto_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_motto_delta_old" ON "dbrdf_motto_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_motto_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 738
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_impactFactor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_impactFactor_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_impactFactor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_impactFactor_delta_old" ON "dbrdf_impactFactor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_impactFactor_delta_old" ON "dbrdf_impactFactor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_impactFactor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 739
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerChoreographer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_formerChoreographer_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_formerChoreographer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_formerChoreographer_delta_old" ON "dbrdf_formerChoreographer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_formerChoreographer_delta_old" ON "dbrdf_formerChoreographer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerChoreographer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 740
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_causalties_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_causalties_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_causalties" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_causalties_delta_old" ON "dbrdf_causalties_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_causalties_delta_old" ON "dbrdf_causalties_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_causalties_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 741
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_participant_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_participant_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_participant" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_participant_delta_old" ON "dbrdf_participant_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_participant_delta_old" ON "dbrdf_participant_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_participant_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 742
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nominee_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nominee_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_nominee" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nominee_delta_old" ON "dbrdf_nominee_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nominee_delta_old" ON "dbrdf_nominee_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nominee_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 743
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_olympicOathSwornByAthlete_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_olympicOathSwornByAthlete_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_olympicOathSwornByAthlete" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_olympicOathSwornByAthlete_delta_old" ON "dbrdf_olympicOathSwornByAthlete_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_olympicOathSwornByAthlete_delta_old" ON "dbrdf_olympicOathSwornByAthlete_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_olympicOathSwornByAthlete_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 744
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mgiid_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mgiid_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_mgiid" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mgiid_delta_old" ON "dbrdf_mgiid_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mgiid_delta_old" ON "dbrdf_mgiid_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mgiid_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 745
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_vehicleCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_vehicleCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_vehicleCode" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_vehicleCode_delta_old" ON "dbrdf_vehicleCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_vehicleCode_delta_old" ON "dbrdf_vehicleCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_vehicleCode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 746
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_irishName_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_irishName_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_irishName" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_irishName_delta_old" ON "dbrdf_irishName_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_irishName_delta_old" ON "dbrdf_irishName_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_irishName_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 747
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_splitFromParty_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_splitFromParty_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_splitFromParty" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_splitFromParty_delta_old" ON "dbrdf_splitFromParty_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_splitFromParty_delta_old" ON "dbrdf_splitFromParty_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_splitFromParty_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 748
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ethnicity_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ethnicity_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_ethnicity" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ethnicity_delta_old" ON "dbrdf_ethnicity_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ethnicity_delta_old" ON "dbrdf_ethnicity_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ethnicity_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 749
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_prominence_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_prominence_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_prominence" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_prominence_delta_old" ON "dbrdf_prominence_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_prominence_delta_old" ON "dbrdf_prominence_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_prominence_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 750
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_ComicsCreator"(s) SELECT DISTINCT t0.s FROM "dbrdf_ComicsCreator_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_ComicsCreator_delta_old";
        INSERT INTO "dbrdf_ComicsCreator_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_ComicsCreator_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ComicsCreator_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 751
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_airDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_airDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_airDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_airDate_delta_old" ON "dbrdf_airDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_airDate_delta_old" ON "dbrdf_airDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_airDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 752
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Monument"(s) SELECT DISTINCT t0.s FROM "dbrdf_Monument_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Monument_delta_old";
        INSERT INTO "dbrdf_Monument_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Monument_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Monument_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 753
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_programCost_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_programCost_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_programCost" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_programCost_delta_old" ON "dbrdf_programCost_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_programCost_delta_old" ON "dbrdf_programCost_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_programCost_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 754
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_icdo_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_icdo_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_icdo" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_icdo_delta_old" ON "dbrdf_icdo_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_icdo_delta_old" ON "dbrdf_icdo_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_icdo_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 755
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_countryWithFirstAstronaut_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_countryWithFirstAstronaut_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_countryWithFirstAstronaut" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_countryWithFirstAstronaut_delta_old" ON "dbrdf_countryWithFirstAstronaut_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_countryWithFirstAstronaut_delta_old" ON "dbrdf_countryWithFirstAstronaut_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_countryWithFirstAstronaut_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 756
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_crews_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_crews_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_crews" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_crews_delta_old" ON "dbrdf_crews_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_crews_delta_old" ON "dbrdf_crews_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_crews_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 757
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_code_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_code_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_code" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_code_delta_old" ON "dbrdf_code_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_code_delta_old" ON "dbrdf_code_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_code_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 758
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Boxer"(s) SELECT DISTINCT t0.s FROM "dbrdf_Boxer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Boxer_delta_old";
        INSERT INTO "dbrdf_Boxer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Boxer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Boxer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 759
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerHighschool_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_formerHighschool_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_formerHighschool" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_formerHighschool_delta_old" ON "dbrdf_formerHighschool_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_formerHighschool_delta_old" ON "dbrdf_formerHighschool_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerHighschool_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 760
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftFighter_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftFighter_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_aircraftFighter" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftFighter_delta_old" ON "dbrdf_aircraftFighter_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftFighter_delta_old" ON "dbrdf_aircraftFighter_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftFighter_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 761
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_seasonNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_seasonNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_seasonNumber" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_seasonNumber_delta_old" ON "dbrdf_seasonNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_seasonNumber_delta_old" ON "dbrdf_seasonNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_seasonNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 762
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_license_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_license_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_license" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_license_delta_old" ON "dbrdf_license_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_license_delta_old" ON "dbrdf_license_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_license_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 763
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mostPopulousCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mostPopulousCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_mostPopulousCountry" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mostPopulousCountry_delta_old" ON "dbrdf_mostPopulousCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mostPopulousCountry_delta_old" ON "dbrdf_mostPopulousCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mostPopulousCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 764
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_railGauge_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_railGauge_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_railGauge" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_railGauge_delta_old" ON "dbrdf_railGauge_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_railGauge_delta_old" ON "dbrdf_railGauge_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_railGauge_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 765
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_vicePrimeMinister_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_vicePrimeMinister_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_vicePrimeMinister" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_vicePrimeMinister_delta_old" ON "dbrdf_vicePrimeMinister_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_vicePrimeMinister_delta_old" ON "dbrdf_vicePrimeMinister_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_vicePrimeMinister_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 766
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_trainerYears_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_trainerYears_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_trainerYears" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_trainerYears_delta_old" ON "dbrdf_trainerYears_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_trainerYears_delta_old" ON "dbrdf_trainerYears_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_trainerYears_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 767
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastLaunch_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lastLaunch_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lastLaunch" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lastLaunch_delta_old" ON "dbrdf_lastLaunch_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lastLaunch_delta_old" ON "dbrdf_lastLaunch_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastLaunch_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 768
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_largestSettlement_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_largestSettlement_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_largestSettlement" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_largestSettlement_delta_old" ON "dbrdf_largestSettlement_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_largestSettlement_delta_old" ON "dbrdf_largestSettlement_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_largestSettlement_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 769
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_bSide_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_bSide_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_bSide" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_bSide_delta_old" ON "dbrdf_bSide_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_bSide_delta_old" ON "dbrdf_bSide_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_bSide_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 770
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dateConstruction_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dateConstruction_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_dateConstruction" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dateConstruction_delta_old" ON "dbrdf_dateConstruction_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dateConstruction_delta_old" ON "dbrdf_dateConstruction_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dateConstruction_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 771
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsSubsection_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_alpsSubsection_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_alpsSubsection" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_alpsSubsection_delta_old" ON "dbrdf_alpsSubsection_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_alpsSubsection_delta_old" ON "dbrdf_alpsSubsection_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsSubsection_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 772
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_outflow_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_outflow_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_outflow" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_outflow_delta_old" ON "dbrdf_outflow_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_outflow_delta_old" ON "dbrdf_outflow_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_outflow_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 773
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_musicSubgenre_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_musicSubgenre_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_musicSubgenre" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_musicSubgenre_delta_old" ON "dbrdf_musicSubgenre_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_musicSubgenre_delta_old" ON "dbrdf_musicSubgenre_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_musicSubgenre_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 774
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Cardinal"(s) SELECT DISTINCT t0.s FROM "dbrdf_Cardinal_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Cardinal_delta_old";
        INSERT INTO "dbrdf_Cardinal_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Cardinal_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Cardinal_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 775
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_premiereYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_premiereYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_premiereYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_premiereYear_delta_old" ON "dbrdf_premiereYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_premiereYear_delta_old" ON "dbrdf_premiereYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_premiereYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 776
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationDensity_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_populationDensity_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_populationDensity0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_populationDensity_delta_old0" ON "dbrdf_populationDensity_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_populationDensity_delta_old0" ON "dbrdf_populationDensity_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationDensity_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_populationDensity0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_populationDensity_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_populationDensity_delta_old0";
        INSERT INTO "dbrdf_populationDensity_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_populationDensity_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_populationDensity_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 777
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaWater_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_areaWater_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_areaWater" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_areaWater_delta_old" ON "dbrdf_areaWater_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_areaWater_delta_old" ON "dbrdf_areaWater_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaWater_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 778
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_landingSite_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_landingSite_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_landingSite" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_landingSite_delta_old" ON "dbrdf_landingSite_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_landingSite_delta_old" ON "dbrdf_landingSite_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_landingSite_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 779
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_borough_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_borough_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_borough" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_borough_delta_old" ON "dbrdf_borough_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_borough_delta_old" ON "dbrdf_borough_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_borough_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 780
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_totalLaunches_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_totalLaunches_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_totalLaunches" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_totalLaunches_delta_old" ON "dbrdf_totalLaunches_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_totalLaunches_delta_old" ON "dbrdf_totalLaunches_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_totalLaunches_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 781
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectEndDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_projectEndDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_projectEndDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_projectEndDate_delta_old" ON "dbrdf_projectEndDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_projectEndDate_delta_old" ON "dbrdf_projectEndDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectEndDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 782
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsMajorSector_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_alpsMajorSector_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_alpsMajorSector" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_alpsMajorSector_delta_old" ON "dbrdf_alpsMajorSector_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_alpsMajorSector_delta_old" ON "dbrdf_alpsMajorSector_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsMajorSector_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 783
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_athletics_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_athletics_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_athletics" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_athletics_delta_old" ON "dbrdf_athletics_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_athletics_delta_old" ON "dbrdf_athletics_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_athletics_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 784
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_associationOfLocalGovernment_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_associationOfLocalGovernment_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_associationOfLocalGovernment" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_associationOfLocalGovernment_delta_old" ON "dbrdf_associationOfLocalGovernment_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_associationOfLocalGovernment_delta_old" ON "dbrdf_associationOfLocalGovernment_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_associationOfLocalGovernment_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 785
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_clubsRecordGoalscorer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_clubsRecordGoalscorer_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_clubsRecordGoalscorer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_clubsRecordGoalscorer_delta_old" ON "dbrdf_clubsRecordGoalscorer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_clubsRecordGoalscorer_delta_old" ON "dbrdf_clubsRecordGoalscorer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_clubsRecordGoalscorer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 786
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_facultySize_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_facultySize_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_facultySize" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_facultySize_delta_old" ON "dbrdf_facultySize_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_facultySize_delta_old" ON "dbrdf_facultySize_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_facultySize_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 787
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_silverMedalist_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_silverMedalist_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_silverMedalist" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_silverMedalist_delta_old" ON "dbrdf_silverMedalist_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_silverMedalist_delta_old" ON "dbrdf_silverMedalist_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_silverMedalist_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 788
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_subregion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_subregion_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_subregion" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_subregion_delta_old" ON "dbrdf_subregion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_subregion_delta_old" ON "dbrdf_subregion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_subregion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 789
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cosparId_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cosparId_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_cosparId" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cosparId_delta_old" ON "dbrdf_cosparId_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_cosparId_delta_old" ON "dbrdf_cosparId_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cosparId_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 790
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_acquirementDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_acquirementDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_acquirementDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_acquirementDate_delta_old" ON "dbrdf_acquirementDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_acquirementDate_delta_old" ON "dbrdf_acquirementDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_acquirementDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 791
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_density1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_density_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_density_delta_old1";
        INSERT INTO "dbrdf_density_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_density_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_density_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 792
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_latestReleaseVersion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_latestReleaseVersion_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_latestReleaseVersion" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_latestReleaseVersion_delta_old" ON "dbrdf_latestReleaseVersion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_latestReleaseVersion_delta_old" ON "dbrdf_latestReleaseVersion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_latestReleaseVersion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 793
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_varietals_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_varietals_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_varietals" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_varietals_delta_old" ON "dbrdf_varietals_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_varietals_delta_old" ON "dbrdf_varietals_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_varietals_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 794
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_beatifiedBy_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_beatifiedBy_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_beatifiedBy" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_beatifiedBy_delta_old" ON "dbrdf_beatifiedBy_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_beatifiedBy_delta_old" ON "dbrdf_beatifiedBy_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_beatifiedBy_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 795
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_RailwayLine"(s) SELECT DISTINCT t0.s FROM "dbrdf_RailwayLine_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_RailwayLine_delta_old";
        INSERT INTO "dbrdf_RailwayLine_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_RailwayLine_delta_new" t0;
        TRUNCATE TABLE "dbrdf_RailwayLine_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 796
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_originalLanguage_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_originalLanguage_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_originalLanguage" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_originalLanguage_delta_old" ON "dbrdf_originalLanguage_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_originalLanguage_delta_old" ON "dbrdf_originalLanguage_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_originalLanguage_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 797
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftUser_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftUser_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_aircraftUser" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftUser_delta_old" ON "dbrdf_aircraftUser_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftUser_delta_old" ON "dbrdf_aircraftUser_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftUser_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 798
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationTotalRanking_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_populationTotalRanking_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_populationTotalRanking" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_populationTotalRanking_delta_old" ON "dbrdf_populationTotalRanking_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_populationTotalRanking_delta_old" ON "dbrdf_populationTotalRanking_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationTotalRanking_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 799
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaOfCatchment_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_areaOfCatchment_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_areaOfCatchment" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_areaOfCatchment_delta_old" ON "dbrdf_areaOfCatchment_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_areaOfCatchment_delta_old" ON "dbrdf_areaOfCatchment_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaOfCatchment_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 800
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_distanceLaps_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_distanceLaps_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_distanceLaps" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_distanceLaps_delta_old" ON "dbrdf_distanceLaps_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_distanceLaps_delta_old" ON "dbrdf_distanceLaps_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_distanceLaps_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 801
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_pubchem_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_pubchem_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_pubchem" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_pubchem_delta_old" ON "dbrdf_pubchem_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_pubchem_delta_old" ON "dbrdf_pubchem_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_pubchem_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 802
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_selection_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_selection_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_selection" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_selection_delta_old" ON "dbrdf_selection_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_selection_delta_old" ON "dbrdf_selection_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_selection_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 803
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstLaunchRocket_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstLaunchRocket_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_firstLaunchRocket" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstLaunchRocket_delta_old" ON "dbrdf_firstLaunchRocket_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstLaunchRocket_delta_old" ON "dbrdf_firstLaunchRocket_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstLaunchRocket_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 804
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastFlight_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lastFlight_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lastFlight" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lastFlight_delta_old" ON "dbrdf_lastFlight_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lastFlight_delta_old" ON "dbrdf_lastFlight_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastFlight_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 805
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_networth_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_networth_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_networth" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_networth_delta_old" ON "dbrdf_networth_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_networth_delta_old" ON "dbrdf_networth_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_networth_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 806
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_freeFlightTime0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_freeFlightTime_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_freeFlightTime_delta_old0";
        INSERT INTO "dbrdf_freeFlightTime_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_freeFlightTime_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_freeFlightTime_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 807
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_significantBuilding_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_significantBuilding_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_significantBuilding" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_significantBuilding_delta_old" ON "dbrdf_significantBuilding_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_significantBuilding_delta_old" ON "dbrdf_significantBuilding_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_significantBuilding_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 808
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_visitorsPerYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_visitorsPerYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_visitorsPerYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_visitorsPerYear_delta_old" ON "dbrdf_visitorsPerYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_visitorsPerYear_delta_old" ON "dbrdf_visitorsPerYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_visitorsPerYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 809
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastLaunchRocket_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lastLaunchRocket_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lastLaunchRocket" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lastLaunchRocket_delta_old" ON "dbrdf_lastLaunchRocket_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lastLaunchRocket_delta_old" ON "dbrdf_lastLaunchRocket_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastLaunchRocket_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 810
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectReferenceID_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_projectReferenceID_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_projectReferenceID" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_projectReferenceID_delta_old" ON "dbrdf_projectReferenceID_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_projectReferenceID_delta_old" ON "dbrdf_projectReferenceID_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectReferenceID_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 811
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mirDockings_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mirDockings_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_mirDockings" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mirDockings_delta_old" ON "dbrdf_mirDockings_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mirDockings_delta_old" ON "dbrdf_mirDockings_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mirDockings_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 812
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationRural_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_populationRural_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_populationRural" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_populationRural_delta_old" ON "dbrdf_populationRural_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_populationRural_delta_old" ON "dbrdf_populationRural_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationRural_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 813
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 814
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_productionEndYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_productionEndYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_productionEndYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_productionEndYear_delta_old" ON "dbrdf_productionEndYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_productionEndYear_delta_old" ON "dbrdf_productionEndYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_productionEndYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 815
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cityType_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cityType_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_cityType" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cityType_delta_old" ON "dbrdf_cityType_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_cityType_delta_old" ON "dbrdf_cityType_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cityType_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 816
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 817
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_brainInfoNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_brainInfoNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_brainInfoNumber" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_brainInfoNumber_delta_old" ON "dbrdf_brainInfoNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_brainInfoNumber_delta_old" ON "dbrdf_brainInfoNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_brainInfoNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 818
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_isoCodeRegion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_isoCodeRegion_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_isoCodeRegion" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_isoCodeRegion_delta_old" ON "dbrdf_isoCodeRegion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_isoCodeRegion_delta_old" ON "dbrdf_isoCodeRegion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_isoCodeRegion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 819
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaTotalRanking_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_areaTotalRanking_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_areaTotalRanking" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_areaTotalRanking_delta_old" ON "dbrdf_areaTotalRanking_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_areaTotalRanking_delta_old" ON "dbrdf_areaTotalRanking_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaTotalRanking_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 820
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_classes_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_classes_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_classes" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_classes_delta_old" ON "dbrdf_classes_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_classes_delta_old" ON "dbrdf_classes_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_classes_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 821
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_NascarDriver"(s) SELECT DISTINCT t0.s FROM "dbrdf_NascarDriver_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_NascarDriver_delta_old";
        INSERT INTO "dbrdf_NascarDriver_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_NascarDriver_delta_new" t0;
        TRUNCATE TABLE "dbrdf_NascarDriver_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 822
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_soocerLeagueSeason_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_soocerLeagueSeason_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_soocerLeagueSeason" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_soocerLeagueSeason_delta_old" ON "dbrdf_soocerLeagueSeason_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_soocerLeagueSeason_delta_old" ON "dbrdf_soocerLeagueSeason_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_soocerLeagueSeason_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 823
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_wingArea_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_wingArea_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_wingArea" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_wingArea_delta_old" ON "dbrdf_wingArea_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_wingArea_delta_old" ON "dbrdf_wingArea_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_wingArea_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 824
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_secondDriver_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_secondDriver_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_secondDriver" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_secondDriver_delta_old" ON "dbrdf_secondDriver_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_secondDriver_delta_old" ON "dbrdf_secondDriver_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_secondDriver_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 825
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfTerritories_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfTerritories_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfTerritories" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfTerritories_delta_old" ON "dbrdf_numberOfTerritories_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfTerritories_delta_old" ON "dbrdf_numberOfTerritories_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfTerritories_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 826
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_provost_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_provost_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_provost" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_provost_delta_old" ON "dbrdf_provost_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_provost_delta_old" ON "dbrdf_provost_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_provost_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 827
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_launchVehicle_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_launchVehicle_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_launchVehicle" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_launchVehicle_delta_old" ON "dbrdf_launchVehicle_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_launchVehicle_delta_old" ON "dbrdf_launchVehicle_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_launchVehicle_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 828
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_species_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_species_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_species" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_species_delta_old" ON "dbrdf_species_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_species_delta_old" ON "dbrdf_species_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_species_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 829
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_zdb_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_zdb_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_zdb" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_zdb_delta_old" ON "dbrdf_zdb_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_zdb_delta_old" ON "dbrdf_zdb_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_zdb_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 830
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_revenue_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_revenue_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_revenue" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_revenue_delta_old" ON "dbrdf_revenue_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_revenue_delta_old" ON "dbrdf_revenue_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_revenue_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 831
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_populationDensity1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_populationDensity_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_populationDensity_delta_old1";
        INSERT INTO "dbrdf_populationDensity_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_populationDensity_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_populationDensity_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 832
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_reservations_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_reservations_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_reservations" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_reservations_delta_old" ON "dbrdf_reservations_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_reservations_delta_old" ON "dbrdf_reservations_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_reservations_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 833
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_grayPage_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_grayPage_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_grayPage" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_grayPage_delta_old" ON "dbrdf_grayPage_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_grayPage_delta_old" ON "dbrdf_grayPage_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_grayPage_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 834
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_feastDay_delta_old"(s integer, o integer) ON COMMIT DROP;
