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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1001
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1002
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1004
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1005
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1006
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstPublicationDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstPublicationDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_firstPublicationDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstPublicationDate_delta_old" ON "dbrdf_firstPublicationDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstPublicationDate_delta_old" ON "dbrdf_firstPublicationDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstPublicationDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1007
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1008
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1009
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1010
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_infantMortality_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_infantMortality_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_infantMortality" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_infantMortality_delta_old" ON "dbrdf_infantMortality_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_infantMortality_delta_old" ON "dbrdf_infantMortality_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_infantMortality_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1011
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1012
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1013
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1014
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1015
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1016
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1017
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1018
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1019
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1020
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1021
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1022
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1023
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1024
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_isPartOfMilitaryConflict_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_isPartOfMilitaryConflict_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_isPartOfMilitaryConflict" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_isPartOfMilitaryConflict_delta_old" ON "dbrdf_isPartOfMilitaryConflict_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_isPartOfMilitaryConflict_delta_old" ON "dbrdf_isPartOfMilitaryConflict_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_isPartOfMilitaryConflict_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1025
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1026
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1027
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1028
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1029
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1030
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1031
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1032
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1033
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1034
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1035
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1036
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1037
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1038
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1039
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1040
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1041
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1042
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1043
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1044
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1045
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1046
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1047
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1048
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1049
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1050
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1051
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1052
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1053
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1054
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_grossDomesticProductAsOf_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_grossDomesticProductAsOf_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_grossDomesticProductAsOf" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_grossDomesticProductAsOf_delta_old" ON "dbrdf_grossDomesticProductAsOf_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_grossDomesticProductAsOf_delta_old" ON "dbrdf_grossDomesticProductAsOf_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_grossDomesticProductAsOf_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1055
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstWinner_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstWinner_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_firstWinner" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstWinner_delta_old" ON "dbrdf_firstWinner_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstWinner_delta_old" ON "dbrdf_firstWinner_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstWinner_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1056
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1057
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_peabodyAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_peabodyAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_peabodyAward" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_peabodyAward_delta_old" ON "dbrdf_peabodyAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_peabodyAward_delta_old" ON "dbrdf_peabodyAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_peabodyAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1058
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1059
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1060
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1061
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1062
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1063
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1064
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_soocerLeaguePromoted_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_soocerLeaguePromoted_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_soocerLeaguePromoted" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_soocerLeaguePromoted_delta_old" ON "dbrdf_soocerLeaguePromoted_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_soocerLeaguePromoted_delta_old" ON "dbrdf_soocerLeaguePromoted_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_soocerLeaguePromoted_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1065
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1066
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1067
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1068
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1069
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1070
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_totalTravellers_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_totalTravellers_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_totalTravellers" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_totalTravellers_delta_old" ON "dbrdf_totalTravellers_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_totalTravellers_delta_old" ON "dbrdf_totalTravellers_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_totalTravellers_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1071
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1072
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumTemperature_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_maximumTemperature_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_maximumTemperature" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_maximumTemperature_delta_old" ON "dbrdf_maximumTemperature_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_maximumTemperature_delta_old" ON "dbrdf_maximumTemperature_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumTemperature_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1073
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lunarSurfaceTime_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lunarSurfaceTime_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lunarSurfaceTime0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lunarSurfaceTime_delta_old0" ON "dbrdf_lunarSurfaceTime_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_lunarSurfaceTime_delta_old0" ON "dbrdf_lunarSurfaceTime_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lunarSurfaceTime_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_lunarSurfaceTime0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lunarSurfaceTime_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_lunarSurfaceTime_delta_old0";
        INSERT INTO "dbrdf_lunarSurfaceTime_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lunarSurfaceTime_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_lunarSurfaceTime_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1074
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1075
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_broadcastTranslator_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_broadcastTranslator_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_broadcastTranslator" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_broadcastTranslator_delta_old" ON "dbrdf_broadcastTranslator_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_broadcastTranslator_delta_old" ON "dbrdf_broadcastTranslator_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_broadcastTranslator_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1076
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_gameArtist_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_gameArtist_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_gameArtist" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_gameArtist_delta_old" ON "dbrdf_gameArtist_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_gameArtist_delta_old" ON "dbrdf_gameArtist_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_gameArtist_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1077
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_CanadianFootballPlayer_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_CanadianFootballPlayer_delta_old"(s) SELECT t0.s FROM "dbrdf_CanadianFootballPlayer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_CanadianFootballPlayer_delta_old" ON "dbrdf_CanadianFootballPlayer_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_CanadianFootballPlayer_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_CanadianFootballPlayer"(s) SELECT DISTINCT t0.s FROM "dbrdf_CanadianFootballPlayer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_CanadianFootballPlayer_delta_old";
        INSERT INTO "dbrdf_CanadianFootballPlayer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_CanadianFootballPlayer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_CanadianFootballPlayer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1078
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaOfCatchment_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_areaOfCatchment_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_areaOfCatchment0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_areaOfCatchment_delta_old0" ON "dbrdf_areaOfCatchment_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_areaOfCatchment_delta_old0" ON "dbrdf_areaOfCatchment_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaOfCatchment_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_areaOfCatchment0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_areaOfCatchment_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_areaOfCatchment_delta_old0";
        INSERT INTO "dbrdf_areaOfCatchment_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_areaOfCatchment_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_areaOfCatchment_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1079
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_otherParty_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_otherParty_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_otherParty" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_otherParty_delta_old" ON "dbrdf_otherParty_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_otherParty_delta_old" ON "dbrdf_otherParty_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_otherParty_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1080
    ---- DEPENDS ON: 1079, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_OfficeHolder_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_OfficeHolder_delta_old"(s) SELECT t0.s FROM "dbrdf_OfficeHolder" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_OfficeHolder_delta_old" ON "dbrdf_OfficeHolder_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_OfficeHolder_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_OfficeHolder"(s) SELECT DISTINCT t0.s FROM "dbrdf_OfficeHolder_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_OfficeHolder_delta_old";
        INSERT INTO "dbrdf_OfficeHolder_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_OfficeHolder_delta_new" t0;
        TRUNCATE TABLE "dbrdf_OfficeHolder_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1081
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_productionYears_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_productionYears_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_productionYears" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_productionYears_delta_old" ON "dbrdf_productionYears_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_productionYears_delta_old" ON "dbrdf_productionYears_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_productionYears_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1082
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_PoloLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_PoloLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_PoloLeague_delta_old";
        INSERT INTO "dbrdf_PoloLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_PoloLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_PoloLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1083
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1084
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1085
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1086
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1087
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_usedInWar_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_usedInWar_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_usedInWar" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_usedInWar_delta_old" ON "dbrdf_usedInWar_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_usedInWar_delta_old" ON "dbrdf_usedInWar_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_usedInWar_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1088
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1089
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfAcademicStaff_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfAcademicStaff_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfAcademicStaff" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfAcademicStaff_delta_old" ON "dbrdf_numberOfAcademicStaff_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfAcademicStaff_delta_old" ON "dbrdf_numberOfAcademicStaff_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfAcademicStaff_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1090
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1091
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1092
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_river_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_river_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_river" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_river_delta_old" ON "dbrdf_river_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_river_delta_old" ON "dbrdf_river_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_river_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1093
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_deliveryDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_deliveryDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_deliveryDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_deliveryDate_delta_old" ON "dbrdf_deliveryDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_deliveryDate_delta_old" ON "dbrdf_deliveryDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_deliveryDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1094
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1095
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1096
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerCoach_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_formerCoach_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_formerCoach" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_formerCoach_delta_old" ON "dbrdf_formerCoach_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_formerCoach_delta_old" ON "dbrdf_formerCoach_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerCoach_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1097
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1098
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1099
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ratio_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ratio_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_ratio" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ratio_delta_old" ON "dbrdf_ratio_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ratio_delta_old" ON "dbrdf_ratio_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ratio_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1100
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_toll_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_toll_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_toll" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_toll_delta_old" ON "dbrdf_toll_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_toll_delta_old" ON "dbrdf_toll_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_toll_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1101
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1102
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1103
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_minimumInclination_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_minimumInclination_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_minimumInclination" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_minimumInclination_delta_old" ON "dbrdf_minimumInclination_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_minimumInclination_delta_old" ON "dbrdf_minimumInclination_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_minimumInclination_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1104
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1105
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1106
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nutsCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nutsCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_nutsCode" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nutsCode_delta_old" ON "dbrdf_nutsCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nutsCode_delta_old" ON "dbrdf_nutsCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nutsCode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1107
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_year_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_year_delta_old"(s, o) SELECT t0.s, t0.o 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, o); CREATE INDEX "IDX_1_dbrdf_year_delta_old" ON "dbrdf_year_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_year_delta_new"(s integer, o 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,?X1) :- <http://dbpedia.org/ontology/year$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_year_delta_new"(s, o) SELECT t1.o, t0.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 AND ex.o = t0.o);


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1108
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1109
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_landingVehicle_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_landingVehicle_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_landingVehicle" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_landingVehicle_delta_old" ON "dbrdf_landingVehicle_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_landingVehicle_delta_old" ON "dbrdf_landingVehicle_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_landingVehicle_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1110
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_supplementalDraftYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_supplementalDraftYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_supplementalDraftYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_supplementalDraftYear_delta_old" ON "dbrdf_supplementalDraftYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_supplementalDraftYear_delta_old" ON "dbrdf_supplementalDraftYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_supplementalDraftYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1111
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1112
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_openingFilm_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_openingFilm_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_openingFilm" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_openingFilm_delta_old" ON "dbrdf_openingFilm_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_openingFilm_delta_old" ON "dbrdf_openingFilm_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_openingFilm_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1113
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1114
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1115
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1116
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_suppreddedDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_suppreddedDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_suppreddedDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_suppreddedDate_delta_old" ON "dbrdf_suppreddedDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_suppreddedDate_delta_old" ON "dbrdf_suppreddedDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_suppreddedDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1117
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mapDescription_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mapDescription_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_mapDescription" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mapDescription_delta_old" ON "dbrdf_mapDescription_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mapDescription_delta_old" ON "dbrdf_mapDescription_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mapDescription_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1118
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_typeOfElectrification_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_typeOfElectrification_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_typeOfElectrification" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_typeOfElectrification_delta_old" ON "dbrdf_typeOfElectrification_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_typeOfElectrification_delta_old" ON "dbrdf_typeOfElectrification_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_typeOfElectrification_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1119
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_organSystem_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_organSystem_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_organSystem" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_organSystem_delta_old" ON "dbrdf_organSystem_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_organSystem_delta_old" ON "dbrdf_organSystem_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_organSystem_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1120
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectBudgetTotal_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_projectBudgetTotal_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_projectBudgetTotal" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_projectBudgetTotal_delta_old" ON "dbrdf_projectBudgetTotal_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_projectBudgetTotal_delta_old" ON "dbrdf_projectBudgetTotal_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectBudgetTotal_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1121
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1122
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1123
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfStars_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfStars_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfStars" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfStars_delta_old" ON "dbrdf_numberOfStars_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfStars_delta_old" ON "dbrdf_numberOfStars_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfStars_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1124
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1125
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_amgid_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_amgid_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_amgid" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_amgid_delta_old" ON "dbrdf_amgid_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_amgid_delta_old" ON "dbrdf_amgid_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_amgid_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1126
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1127
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1128
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1129
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_recordDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_recordDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_recordDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_recordDate_delta_old" ON "dbrdf_recordDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_recordDate_delta_old" ON "dbrdf_recordDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_recordDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1130
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_iataLocationIdentifier_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_iataLocationIdentifier_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_iataLocationIdentifier" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_iataLocationIdentifier_delta_old" ON "dbrdf_iataLocationIdentifier_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_iataLocationIdentifier_delta_old" ON "dbrdf_iataLocationIdentifier_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_iataLocationIdentifier_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1131
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_buildingEndYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_buildingEndYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_buildingEndYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_buildingEndYear_delta_old" ON "dbrdf_buildingEndYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_buildingEndYear_delta_old" ON "dbrdf_buildingEndYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_buildingEndYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1132
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1133
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1134
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_parentOrganisation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_parentOrganisation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_parentOrganisation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_parentOrganisation_delta_old" ON "dbrdf_parentOrganisation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_parentOrganisation_delta_old" ON "dbrdf_parentOrganisation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_parentOrganisation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1135
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1136
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_openingDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_openingDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_openingDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_openingDate_delta_old" ON "dbrdf_openingDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_openingDate_delta_old" ON "dbrdf_openingDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_openingDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1137
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_beatifiedPlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_beatifiedPlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_beatifiedPlace" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_beatifiedPlace_delta_old" ON "dbrdf_beatifiedPlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_beatifiedPlace_delta_old" ON "dbrdf_beatifiedPlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_beatifiedPlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1138
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1139
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1140
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_modelStartYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_modelStartYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_modelStartYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_modelStartYear_delta_old" ON "dbrdf_modelStartYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_modelStartYear_delta_old" ON "dbrdf_modelStartYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_modelStartYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1141
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1142
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1143
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1144
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1145
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1146
    ---- DEPENDS ON: 1145, 886, 833, 647, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_TennisPlayer_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_TennisPlayer_delta_old"(s) SELECT t0.s FROM "dbrdf_TennisPlayer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_TennisPlayer_delta_old" ON "dbrdf_TennisPlayer_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_TennisPlayer_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1147
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1148
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_gross_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_gross_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_gross" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_gross_delta_old" ON "dbrdf_gross_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_gross_delta_old" ON "dbrdf_gross_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_gross_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1149
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_MixedMartialArtsLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_MixedMartialArtsLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_MixedMartialArtsLeague_delta_old";
        INSERT INTO "dbrdf_MixedMartialArtsLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_MixedMartialArtsLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_MixedMartialArtsLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1150
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_cmpEvaDuration0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cmpEvaDuration_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_cmpEvaDuration_delta_old0";
        INSERT INTO "dbrdf_cmpEvaDuration_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cmpEvaDuration_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_cmpEvaDuration_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1151
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfWineries_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfWineries_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfWineries" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfWineries_delta_old" ON "dbrdf_numberOfWineries_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfWineries_delta_old" ON "dbrdf_numberOfWineries_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfWineries_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1152
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_canonizedBy_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_canonizedBy_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_canonizedBy" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_canonizedBy_delta_old" ON "dbrdf_canonizedBy_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_canonizedBy_delta_old" ON "dbrdf_canonizedBy_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_canonizedBy_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1153
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfMembersAsOf_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfMembersAsOf_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfMembersAsOf" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfMembersAsOf_delta_old" ON "dbrdf_numberOfMembersAsOf_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfMembersAsOf_delta_old" ON "dbrdf_numberOfMembersAsOf_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfMembersAsOf_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1154
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_trainer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_trainer_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_trainer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_trainer_delta_old" ON "dbrdf_trainer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_trainer_delta_old" ON "dbrdf_trainer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_trainer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1155
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1156
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftRecon_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftRecon_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_aircraftRecon" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftRecon_delta_old" ON "dbrdf_aircraftRecon_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftRecon_delta_old" ON "dbrdf_aircraftRecon_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftRecon_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1157
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_coastLine_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_coastLine_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_coastLine" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_coastLine_delta_old" ON "dbrdf_coastLine_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_coastLine_delta_old" ON "dbrdf_coastLine_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_coastLine_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1158
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_europeanParliamentGroup_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_europeanParliamentGroup_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_europeanParliamentGroup" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_europeanParliamentGroup_delta_old" ON "dbrdf_europeanParliamentGroup_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_europeanParliamentGroup_delta_old" ON "dbrdf_europeanParliamentGroup_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_europeanParliamentGroup_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1159
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_militaryRank_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_militaryRank_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_militaryRank" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_militaryRank_delta_old" ON "dbrdf_militaryRank_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_militaryRank_delta_old" ON "dbrdf_militaryRank_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_militaryRank_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1160
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_demolitionYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_demolitionYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_demolitionYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_demolitionYear_delta_old" ON "dbrdf_demolitionYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_demolitionYear_delta_old" ON "dbrdf_demolitionYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_demolitionYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1161
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_layout_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_layout_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_layout" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_layout_delta_old" ON "dbrdf_layout_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_layout_delta_old" ON "dbrdf_layout_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_layout_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1162
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1163
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_staff_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_staff_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_staff" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_staff_delta_old" ON "dbrdf_staff_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_staff_delta_old" ON "dbrdf_staff_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_staff_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1164
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1165
    ---- DEPENDS ON: 1164, 548, 388, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_ChemicalCompound"(s) SELECT DISTINCT t0.s FROM "dbrdf_ChemicalCompound_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_ChemicalCompound_delta_old";
        INSERT INTO "dbrdf_ChemicalCompound_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_ChemicalCompound_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ChemicalCompound_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1166
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_eloRecord_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_eloRecord_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_eloRecord" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_eloRecord_delta_old" ON "dbrdf_eloRecord_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_eloRecord_delta_old" ON "dbrdf_eloRecord_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_eloRecord_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1167
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


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


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


        -- Propagate $delta_new

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

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1168
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_previousEditor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_previousEditor_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_previousEditor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_previousEditor_delta_old" ON "dbrdf_previousEditor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_previousEditor_delta_old" ON "dbrdf_previousEditor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_previousEditor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1169
    ---- DEPENDS ON: 1168, 452, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Magazine"(s) SELECT DISTINCT t0.s FROM "dbrdf_Magazine_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Magazine_delta_old";
        INSERT INTO "dbrdf_Magazine_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Magazine_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Magazine_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1170
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_crewMember_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_crewMember_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_crewMember" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_crewMember_delta_old" ON "dbrdf_crewMember_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_crewMember_delta_old" ON "dbrdf_crewMember_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_crewMember_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1171
    ---- DEPENDS ON: 1170, 1105, 839, 122, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

