        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 137
    ---- 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 138
    ---- 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 139
    ---- 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 140
    ---- 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 141
    ---- 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 142
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtKLPGA_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtKLPGA_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_winsAtKLPGA" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtKLPGA_delta_old" ON "dbrdf_winsAtKLPGA_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtKLPGA_delta_old" ON "dbrdf_winsAtKLPGA_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtKLPGA_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 143
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_portfolio_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_portfolio_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_portfolio" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_portfolio_delta_old" ON "dbrdf_portfolio_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_portfolio_delta_old" ON "dbrdf_portfolio_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_portfolio_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 144
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_majorityFloorLeader_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_majorityFloorLeader_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_majorityFloorLeader" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_majorityFloorLeader_delta_old" ON "dbrdf_majorityFloorLeader_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_majorityFloorLeader_delta_old" ON "dbrdf_majorityFloorLeader_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_majorityFloorLeader_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 145
    ---- 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 146
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sexualOrientation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sexualOrientation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_sexualOrientation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sexualOrientation_delta_old" ON "dbrdf_sexualOrientation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sexualOrientation_delta_old" ON "dbrdf_sexualOrientation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sexualOrientation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 147
    ---- 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 148
    ---- 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/populationDensity$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/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/populationDensity$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/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 149
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_apoapsis_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_apoapsis_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_apoapsis0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_apoapsis_delta_old0" ON "dbrdf_apoapsis_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_apoapsis_delta_old0" ON "dbrdf_apoapsis_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_apoapsis_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_apoapsis0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_apoapsis_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_apoapsis_delta_old0";
        INSERT INTO "dbrdf_apoapsis_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_apoapsis_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_apoapsis_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 150
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_notableIdea_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_notableIdea_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_notableIdea" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_notableIdea_delta_old" ON "dbrdf_notableIdea_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_notableIdea_delta_old" ON "dbrdf_notableIdea_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_notableIdea_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 151
    ---- 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 152
    ---- 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 153
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_pastMember_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_pastMember_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_pastMember" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_pastMember_delta_old" ON "dbrdf_pastMember_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_pastMember_delta_old" ON "dbrdf_pastMember_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_pastMember_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 154
    ---- 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;
    INSERT INTO "dbrdf_feastDay_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_feastDay" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_feastDay_delta_old" ON "dbrdf_feastDay_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_feastDay_delta_old" ON "dbrdf_feastDay_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_feastDay_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 155
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_VicePresident"(s) SELECT DISTINCT t0.s FROM "dbrdf_VicePresident_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_VicePresident_delta_old";
        INSERT INTO "dbrdf_VicePresident_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_VicePresident_delta_new" t0;
        TRUNCATE TABLE "dbrdf_VicePresident_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 156
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 157
    ---- 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/density$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/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/density$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/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 158
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 159
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 160
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_successfulLaunches_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_successfulLaunches_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_successfulLaunches" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_successfulLaunches_delta_old" ON "dbrdf_successfulLaunches_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_successfulLaunches_delta_old" ON "dbrdf_successfulLaunches_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_successfulLaunches_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 161
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_periapsis_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_periapsis_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_periapsis" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_periapsis_delta_old" ON "dbrdf_periapsis_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_periapsis_delta_old" ON "dbrdf_periapsis_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_periapsis_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 162
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 163
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_certificationDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_certificationDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_certificationDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_certificationDate_delta_old" ON "dbrdf_certificationDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_certificationDate_delta_old" ON "dbrdf_certificationDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_certificationDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 164
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 165
    ---- 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 166
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 167
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtLPGA_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtLPGA_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_winsAtLPGA" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtLPGA_delta_old" ON "dbrdf_winsAtLPGA_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtLPGA_delta_old" ON "dbrdf_winsAtLPGA_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtLPGA_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 168
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_volume_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_volume_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_volume" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_volume_delta_old" ON "dbrdf_volume_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_volume_delta_old" ON "dbrdf_volume_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_volume_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 169
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 170
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_wikiPageRevisionID_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_wikiPageRevisionID_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_wikiPageRevisionID" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_wikiPageRevisionID_delta_old" ON "dbrdf_wikiPageRevisionID_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_wikiPageRevisionID_delta_old" ON "dbrdf_wikiPageRevisionID_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_wikiPageRevisionID_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 171
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 172
    ---- 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 173
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 174
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 175
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_terytCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_terytCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_terytCode" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_terytCode_delta_old" ON "dbrdf_terytCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_terytCode_delta_old" ON "dbrdf_terytCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_terytCode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 176
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_iupacName_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_iupacName_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_iupacName" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_iupacName_delta_old" ON "dbrdf_iupacName_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_iupacName_delta_old" ON "dbrdf_iupacName_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_iupacName_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 177
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 178
    ---- 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 179
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 180
    ---- 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 181
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 182
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 183
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 184
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_throwingSide_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_throwingSide_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_throwingSide" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_throwingSide_delta_old" ON "dbrdf_throwingSide_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_throwingSide_delta_old" ON "dbrdf_throwingSide_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_throwingSide_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 185
    ---- 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/Spacecraft/port2DockedTime$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Spacecraft/port2DockedTime$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_port2DockedTime_delta_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/Spacecraft/port2DockedTime$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/Spacecraft/port2DockedTime$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_port2DockedTime_delta_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 186
    ---- 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 187
    ---- 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 188
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 189
    ---- 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 190
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_requirement_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_requirement_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_requirement" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_requirement_delta_old" ON "dbrdf_requirement_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_requirement_delta_old" ON "dbrdf_requirement_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_requirement_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 191
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 192
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 193
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Fungus"(s) SELECT DISTINCT t0.s FROM "dbrdf_Fungus_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Fungus_delta_old";
        INSERT INTO "dbrdf_Fungus_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Fungus_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Fungus_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 194
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_FootballMatch"(s) SELECT DISTINCT t0.s FROM "dbrdf_FootballMatch_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_FootballMatch_delta_old";
        INSERT INTO "dbrdf_FootballMatch_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_FootballMatch_delta_new" t0;
        TRUNCATE TABLE "dbrdf_FootballMatch_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 195
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 196
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_port1_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_port1_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_port1" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_port1_delta_old" ON "dbrdf_port1_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_port1_delta_old" ON "dbrdf_port1_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_port1_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 197
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_province_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_province_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_province" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_province_delta_old" ON "dbrdf_province_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_province_delta_old" ON "dbrdf_province_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_province_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 198
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 199
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 200
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 201
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_starring_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_starring_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_starring" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_starring_delta_old" ON "dbrdf_starring_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_starring_delta_old" ON "dbrdf_starring_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_starring_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/property/starring$delta_new>(?Y,?X1) :- <http://dbpedia.org/property/starring$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_starring_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_starring_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_starring" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/property/starring$delta_new>(?X0,?Y) :- <http://dbpedia.org/property/starring$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_starring_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_starring_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_starring" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 202
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_equipment_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_equipment_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_equipment" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_equipment_delta_old" ON "dbrdf_equipment_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_equipment_delta_old" ON "dbrdf_equipment_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_equipment_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 203
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 204
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 205
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 206
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_height1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_height_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_height_delta_old1";
        INSERT INTO "dbrdf_height_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_height_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_height_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 207
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 208
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 209
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_SpeedwayTeam"(s) SELECT DISTINCT t0.s FROM "dbrdf_SpeedwayTeam_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SpeedwayTeam_delta_old";
        INSERT INTO "dbrdf_SpeedwayTeam_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SpeedwayTeam_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SpeedwayTeam_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 210
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_garrison_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_garrison_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_garrison" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_garrison_delta_old" ON "dbrdf_garrison_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_garrison_delta_old" ON "dbrdf_garrison_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_garrison_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 211
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 212
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 213
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 214
    ---- 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 215
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 216
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 217
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 218
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Deputy"(s) SELECT DISTINCT t0.s FROM "dbrdf_Deputy_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Deputy_delta_old";
        INSERT INTO "dbrdf_Deputy_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Deputy_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Deputy_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 219
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 220
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_affiliation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_affiliation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_affiliation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_affiliation_delta_old" ON "dbrdf_affiliation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_affiliation_delta_old" ON "dbrdf_affiliation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_affiliation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 221
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_simcCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_simcCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_simcCode" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_simcCode_delta_old" ON "dbrdf_simcCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_simcCode_delta_old" ON "dbrdf_simcCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_simcCode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 222
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 223
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 224
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 225
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_routeStart_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_routeStart_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_routeStart" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_routeStart_delta_old" ON "dbrdf_routeStart_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_routeStart_delta_old" ON "dbrdf_routeStart_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_routeStart_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 226
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 227
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 228
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 229
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_chancellor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_chancellor_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_chancellor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_chancellor_delta_old" ON "dbrdf_chancellor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_chancellor_delta_old" ON "dbrdf_chancellor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_chancellor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 230
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 231
    ---- 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 232
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_orbitalPeriod_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_orbitalPeriod_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_orbitalPeriod" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_orbitalPeriod_delta_old" ON "dbrdf_orbitalPeriod_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_orbitalPeriod_delta_old" ON "dbrdf_orbitalPeriod_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_orbitalPeriod_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 233
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 234
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 235
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 236
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_creator_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_creator_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_creator" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_creator_delta_old" ON "dbrdf_creator_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_creator_delta_old" ON "dbrdf_creator_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_creator_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 237
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 238
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 239
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 240
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_assembly_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_assembly_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_assembly" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_assembly_delta_old" ON "dbrdf_assembly_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_assembly_delta_old" ON "dbrdf_assembly_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_assembly_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 241
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 242
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 243
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 244
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_configuration_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_configuration_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_configuration" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_configuration_delta_old" ON "dbrdf_configuration_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_configuration_delta_old" ON "dbrdf_configuration_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_configuration_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 245
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 246
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 247
    ---- 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 248
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 249
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_headLabel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_headLabel_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_headLabel" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_headLabel_delta_old" ON "dbrdf_headLabel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_headLabel_delta_old" ON "dbrdf_headLabel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_headLabel_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 250
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_operatingSystem_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_operatingSystem_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_operatingSystem" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_operatingSystem_delta_old" ON "dbrdf_operatingSystem_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_operatingSystem_delta_old" ON "dbrdf_operatingSystem_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_operatingSystem_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 251
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtSenEuro_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtSenEuro_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_winsAtSenEuro" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtSenEuro_delta_old" ON "dbrdf_winsAtSenEuro_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtSenEuro_delta_old" ON "dbrdf_winsAtSenEuro_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtSenEuro_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 252
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 253
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_postalCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_postalCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_postalCode" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_postalCode_delta_old" ON "dbrdf_postalCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_postalCode_delta_old" ON "dbrdf_postalCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_postalCode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 254
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 255
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 256
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 257
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtChallenges_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtChallenges_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_winsAtChallenges" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtChallenges_delta_old" ON "dbrdf_winsAtChallenges_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtChallenges_delta_old" ON "dbrdf_winsAtChallenges_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtChallenges_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 258
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Swimmer"(s) SELECT DISTINCT t0.s FROM "dbrdf_Swimmer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Swimmer_delta_old";
        INSERT INTO "dbrdf_Swimmer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Swimmer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Swimmer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 259
    ---- 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 260
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_minimumDischarge_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_minimumDischarge_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_minimumDischarge" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_minimumDischarge_delta_old" ON "dbrdf_minimumDischarge_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_minimumDischarge_delta_old" ON "dbrdf_minimumDischarge_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_minimumDischarge_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 261
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nobelLaureates_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nobelLaureates_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_nobelLaureates" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nobelLaureates_delta_old" ON "dbrdf_nobelLaureates_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nobelLaureates_delta_old" ON "dbrdf_nobelLaureates_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nobelLaureates_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 262
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 263
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 264
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 265
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 266
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 267
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 268
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_class_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_class_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_class" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_class_delta_old" ON "dbrdf_class_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_class_delta_old" ON "dbrdf_class_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_class_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 269
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 270
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_trackNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_trackNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_trackNumber" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_trackNumber_delta_old" ON "dbrdf_trackNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_trackNumber_delta_old" ON "dbrdf_trackNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_trackNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 271
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_weight0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_weight_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_weight_delta_old0";
        INSERT INTO "dbrdf_weight_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_weight_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_weight_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 272
    ---- 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 273
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_discharge_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_discharge_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_discharge" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_discharge_delta_old" ON "dbrdf_discharge_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_discharge_delta_old" ON "dbrdf_discharge_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_discharge_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 274
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 275
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 276
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 277
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 278
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_engineType_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_engineType_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_engineType" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_engineType_delta_old" ON "dbrdf_engineType_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_engineType_delta_old" ON "dbrdf_engineType_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_engineType_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 279
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 280
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_temperature_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_temperature_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_temperature" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_temperature_delta_old" ON "dbrdf_temperature_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_temperature_delta_old" ON "dbrdf_temperature_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_temperature_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 281
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 282
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_boilingPoint_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_boilingPoint_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_boilingPoint" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_boilingPoint_delta_old" ON "dbrdf_boilingPoint_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_boilingPoint_delta_old" ON "dbrdf_boilingPoint_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_boilingPoint_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 283
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstPopularVote_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstPopularVote_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_firstPopularVote" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstPopularVote_delta_old" ON "dbrdf_firstPopularVote_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstPopularVote_delta_old" ON "dbrdf_firstPopularVote_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstPopularVote_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 284
    ---- 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 285
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_timeInSpace_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_timeInSpace_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_timeInSpace0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_timeInSpace_delta_old0" ON "dbrdf_timeInSpace_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_timeInSpace_delta_old0" ON "dbrdf_timeInSpace_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_timeInSpace_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_timeInSpace0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_timeInSpace_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_timeInSpace_delta_old0";
        INSERT INTO "dbrdf_timeInSpace_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_timeInSpace_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_timeInSpace_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 286
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_co2Emission0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_co2Emission_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_co2Emission_delta_old0";
        INSERT INTO "dbrdf_co2Emission_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_co2Emission_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_co2Emission_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 287
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 288
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 289
    ---- 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 290
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 291
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_computingInput_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_computingInput_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_computingInput" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_computingInput_delta_old" ON "dbrdf_computingInput_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_computingInput_delta_old" ON "dbrdf_computingInput_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_computingInput_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 292
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 293
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_boilingPoint_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_boilingPoint_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_boilingPoint0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_boilingPoint_delta_old0" ON "dbrdf_boilingPoint_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_boilingPoint_delta_old0" ON "dbrdf_boilingPoint_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_boilingPoint_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 294
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 295
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 296
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_EurovisionSongContestEntry"(s) SELECT DISTINCT t0.s FROM "dbrdf_EurovisionSongContestEntry_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_EurovisionSongContestEntry_delta_old";
        INSERT INTO "dbrdf_EurovisionSongContestEntry_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_EurovisionSongContestEntry_delta_new" t0;
        TRUNCATE TABLE "dbrdf_EurovisionSongContestEntry_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 297
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 298
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 299
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 300
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_port2_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_port2_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_port2" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_port2_delta_old" ON "dbrdf_port2_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_port2_delta_old" ON "dbrdf_port2_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_port2_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 301
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfEmployees_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfEmployees_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfEmployees" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfEmployees_delta_old" ON "dbrdf_numberOfEmployees_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfEmployees_delta_old" ON "dbrdf_numberOfEmployees_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfEmployees_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 302
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 303
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_programmingLanguage_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_programmingLanguage_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_programmingLanguage" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_programmingLanguage_delta_old" ON "dbrdf_programmingLanguage_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_programmingLanguage_delta_old" ON "dbrdf_programmingLanguage_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_programmingLanguage_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 304
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_meanTemperature0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_meanTemperature_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_meanTemperature_delta_old0";
        INSERT INTO "dbrdf_meanTemperature_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_meanTemperature_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_meanTemperature_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 305
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_portrayer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_portrayer_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_portrayer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_portrayer_delta_old" ON "dbrdf_portrayer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_portrayer_delta_old" ON "dbrdf_portrayer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_portrayer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 306
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_coolingSystem_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_coolingSystem_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_coolingSystem" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_coolingSystem_delta_old" ON "dbrdf_coolingSystem_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_coolingSystem_delta_old" ON "dbrdf_coolingSystem_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_coolingSystem_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 307
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_fc_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_fc_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_fc" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_fc_delta_old" ON "dbrdf_fc_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_fc_delta_old" ON "dbrdf_fc_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_fc_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 308
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_managementCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_managementCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_managementCountry" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_managementCountry_delta_old" ON "dbrdf_managementCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_managementCountry_delta_old" ON "dbrdf_managementCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_managementCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 309
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 310
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_battingSide_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_battingSide_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_battingSide" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_battingSide_delta_old" ON "dbrdf_battingSide_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_battingSide_delta_old" ON "dbrdf_battingSide_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_battingSide_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 311
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nisCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nisCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_nisCode" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nisCode_delta_old" ON "dbrdf_nisCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nisCode_delta_old" ON "dbrdf_nisCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nisCode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

