        INSERT INTO "dbrdf_artist_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_artist_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_artist" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1803
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_circulation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_circulation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_circulation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_circulation_delta_old" ON "dbrdf_circulation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_circulation_delta_old" ON "dbrdf_circulation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_circulation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1804
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_highestPosition_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_highestPosition_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_highestPosition" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_highestPosition_delta_old" ON "dbrdf_highestPosition_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_highestPosition_delta_old" ON "dbrdf_highestPosition_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_highestPosition_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1805
    ---- DEPENDS ON: 1804, 1676, 1646, 1055, 858, 400, 317, 46, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://www.w3.org/2003/01/geo/wgs84_pos#SpatialThing>(?X1) :- <http://dbpedia.org/ontology/highestPosition>(?X,?X1) .
    INSERT INTO "dbrdf_SpatialThing"(s) SELECT DISTINCT t0.o FROM "dbrdf_highestPosition" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_SpatialThing" ex WHERE ex.s = t0.o);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://www.w3.org/2003/01/geo/wgs84_pos#SpatialThing>(?X1) :- <http://dbpedia.org/ontology/sourceConfluencePosition>(?X,?X1) .
    INSERT INTO "dbrdf_SpatialThing"(s) SELECT DISTINCT t0.o FROM "dbrdf_sourceConfluencePosition" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_SpatialThing" ex WHERE ex.s = t0.o);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://www.w3.org/2003/01/geo/wgs84_pos#SpatialThing>(?X1) :- <http://dbpedia.org/ontology/mouthPosition>(?X,?X1) .
    INSERT INTO "dbrdf_SpatialThing"(s) SELECT DISTINCT t0.o FROM "dbrdf_mouthPosition" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_SpatialThing" ex WHERE ex.s = t0.o);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://www.w3.org/2003/01/geo/wgs84_pos#SpatialThing>(?X1) :- <http://dbpedia.org/ontology/lowestPosition>(?X,?X1) .
    INSERT INTO "dbrdf_SpatialThing"(s) SELECT DISTINCT t0.o FROM "dbrdf_lowestPosition" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_SpatialThing" ex WHERE ex.s = t0.o);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://www.w3.org/2003/01/geo/wgs84_pos#SpatialThing>(?X1) :- <http://dbpedia.org/ontology/restingPlacePosition>(?X,?X1) .
    INSERT INTO "dbrdf_SpatialThing"(s) SELECT DISTINCT t0.o FROM "dbrdf_restingPlacePosition" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_SpatialThing" ex WHERE ex.s = t0.o);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://www.w3.org/2003/01/geo/wgs84_pos#SpatialThing>(?X1) :- <http://dbpedia.org/ontology/capitalPosition>(?X,?X1) .
    INSERT INTO "dbrdf_SpatialThing"(s) SELECT DISTINCT t0.o FROM "dbrdf_capitalPosition" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_SpatialThing" ex WHERE ex.s = t0.o);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://www.w3.org/2003/01/geo/wgs84_pos#SpatialThing>(?X1) :- <http://dbpedia.org/ontology/governmentPosition>(?X,?X1) .
    INSERT INTO "dbrdf_SpatialThing"(s) SELECT DISTINCT t0.o FROM "dbrdf_governmentPosition" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_SpatialThing" ex WHERE ex.s = t0.o);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://www.w3.org/2003/01/geo/wgs84_pos#SpatialThing>(?X1) :- <http://dbpedia.org/ontology/sourcePosition>(?X,?X1) .
    INSERT INTO "dbrdf_SpatialThing"(s) SELECT DISTINCT t0.o FROM "dbrdf_sourcePosition" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_SpatialThing" ex WHERE ex.s = t0.o);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_SpatialThing_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SpatialThing_delta_old"(s) SELECT t0.s FROM "dbrdf_SpatialThing" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SpatialThing_delta_old" ON "dbrdf_SpatialThing_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SpatialThing_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://www.w3.org/2003/01/geo/wgs84_pos#SpatialThing$delta_new>(?Y) :- <http://www.w3.org/2003/01/geo/wgs84_pos#SpatialThing$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_SpatialThing_delta_new"(s) SELECT t1.o FROM "dbrdf_SpatialThing_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_SpatialThing" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_SpatialThing"(s) SELECT DISTINCT t0.s FROM "dbrdf_SpatialThing_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SpatialThing_delta_old";
        INSERT INTO "dbrdf_SpatialThing_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SpatialThing_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SpatialThing_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1806
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_subtitle_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_subtitle_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_subtitle" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_subtitle_delta_old" ON "dbrdf_subtitle_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_subtitle_delta_old" ON "dbrdf_subtitle_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_subtitle_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1807
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_intercommunality_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_intercommunality_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_intercommunality" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_intercommunality_delta_old" ON "dbrdf_intercommunality_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_intercommunality_delta_old" ON "dbrdf_intercommunality_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_intercommunality_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1808
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_publiclyAccessible_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_publiclyAccessible_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_publiclyAccessible" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_publiclyAccessible_delta_old" ON "dbrdf_publiclyAccessible_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_publiclyAccessible_delta_old" ON "dbrdf_publiclyAccessible_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_publiclyAccessible_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1809
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_availableSmartCard_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_availableSmartCard_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_availableSmartCard" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_availableSmartCard_delta_old" ON "dbrdf_availableSmartCard_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_availableSmartCard_delta_old" ON "dbrdf_availableSmartCard_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_availableSmartCard_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1810
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_agencyStationCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_agencyStationCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_agencyStationCode" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_agencyStationCode_delta_old" ON "dbrdf_agencyStationCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_agencyStationCode_delta_old" ON "dbrdf_agencyStationCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_agencyStationCode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1811
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_weight3"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_weight_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_weight_delta_old3";
        INSERT INTO "dbrdf_weight_delta_old3"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_weight_delta_new3" t0;
        TRUNCATE TABLE "dbrdf_weight_delta_new3";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1812
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfFilms_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfFilms_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfFilms" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfFilms_delta_old" ON "dbrdf_numberOfFilms_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfFilms_delta_old" ON "dbrdf_numberOfFilms_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfFilms_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1813
    ---- DEPENDS ON: 1812, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/AdultActor>(?X) :- <http://dbpedia.org/ontology/numberOfFilms>(?X,?X1) .
    INSERT INTO "dbrdf_AdultActor"(s) SELECT DISTINCT t0.s FROM "dbrdf_numberOfFilms" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_AdultActor" 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_AdultActor_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_AdultActor_delta_old"(s) SELECT t0.s FROM "dbrdf_AdultActor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_AdultActor_delta_old" ON "dbrdf_AdultActor_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_AdultActor_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/AdultActor$delta_new>(?Y) :- <http://dbpedia.org/ontology/AdultActor$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_AdultActor_delta_new"(s) SELECT t1.o FROM "dbrdf_AdultActor_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_AdultActor" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_AdultActor"(s) SELECT DISTINCT t0.s FROM "dbrdf_AdultActor_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_AdultActor_delta_old";
        INSERT INTO "dbrdf_AdultActor_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_AdultActor_delta_new" t0;
        TRUNCATE TABLE "dbrdf_AdultActor_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1814
    ---- DEPENDS ON: 850, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/GivenName>(?X) :- <http://dbpedia.org/ontology/nameDay>(?X,?X1) .
    INSERT INTO "dbrdf_GivenName"(s) SELECT DISTINCT t0.s FROM "dbrdf_nameDay" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_GivenName" 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_GivenName_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_GivenName_delta_old"(s) SELECT t0.s FROM "dbrdf_GivenName" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_GivenName_delta_old" ON "dbrdf_GivenName_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_GivenName_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/GivenName$delta_new>(?Y) :- <http://dbpedia.org/ontology/GivenName$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_GivenName_delta_new"(s) SELECT t1.o FROM "dbrdf_GivenName_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_GivenName" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_GivenName"(s) SELECT DISTINCT t0.s FROM "dbrdf_GivenName_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_GivenName_delta_old";
        INSERT INTO "dbrdf_GivenName_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_GivenName_delta_new" t0;
        TRUNCATE TABLE "dbrdf_GivenName_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1815
    ---- DEPENDS ON: 1814, 1628, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- [Rule] <http://dbpedia.org/ontology/Name>(?X) :- <http://dbpedia.org/ontology/Surname>(?X) .
    INSERT INTO "dbrdf_Name"(s) SELECT t0.s FROM "dbrdf_Surname" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Name" 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_Name_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Name_delta_old"(s) SELECT t0.s FROM "dbrdf_Name" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Name_delta_old" ON "dbrdf_Name_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Name_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/Name$delta_new>(?Y) :- <http://dbpedia.org/ontology/Name$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Name_delta_new"(s) SELECT t1.o FROM "dbrdf_Name_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Name" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Name"(s) SELECT DISTINCT t0.s FROM "dbrdf_Name_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Name_delta_old";
        INSERT INTO "dbrdf_Name_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Name_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Name_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1816
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_guest_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_guest_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_guest" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_guest_delta_old" ON "dbrdf_guest_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_guest_delta_old" ON "dbrdf_guest_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_guest_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1817
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_managementRegion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_managementRegion_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_managementRegion" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_managementRegion_delta_old" ON "dbrdf_managementRegion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_managementRegion_delta_old" ON "dbrdf_managementRegion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_managementRegion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1818
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_seniority_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_seniority_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_seniority" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_seniority_delta_old" ON "dbrdf_seniority_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_seniority_delta_old" ON "dbrdf_seniority_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_seniority_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1819
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_campus_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_campus_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_campus" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_campus_delta_old" ON "dbrdf_campus_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_campus_delta_old" ON "dbrdf_campus_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_campus_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1820
    ---- DEPENDS ON: 1819, 1051, 895, 826, 783, 379, 363, 200, 119, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/University>(?X) :- <http://dbpedia.org/ontology/officerInCharge>(?X,?X1) .
    INSERT INTO "dbrdf_University0"(s) SELECT DISTINCT t0.s FROM "dbrdf_officerInCharge" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_University0" 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_College_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_College_delta_old"(s) SELECT t0.s FROM "dbrdf_College" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_College_delta_old" ON "dbrdf_College_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_College_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_CollegeOrUniversity_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_CollegeOrUniversity_delta_old"(s) SELECT t0.s FROM "dbrdf_CollegeOrUniversity" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_CollegeOrUniversity_delta_old" ON "dbrdf_CollegeOrUniversity_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_CollegeOrUniversity_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_University_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_University_delta_old"(s) SELECT t0.s FROM "dbrdf_University0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_University_delta_old" ON "dbrdf_University_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_University_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/College$delta_new>(?X) :- <http://schema.org/CollegeOrUniversity$delta_old>(?X) .
        INSERT INTO "dbrdf_College_delta_new"(s) SELECT t0.s FROM "dbrdf_CollegeOrUniversity_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_College" ex WHERE ex.s = t0.s);


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


        -- <http://schema.org/CollegeOrUniversity$delta_new>(?X) :- <http://dbpedia.org/ontology/University$delta_old>(?X) .
        INSERT INTO "dbrdf_CollegeOrUniversity_delta_new"(s) SELECT t0.s FROM "dbrdf_University_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_CollegeOrUniversity" ex WHERE ex.s = t0.s);


        -- <http://schema.org/CollegeOrUniversity$delta_new>(?X) :- <http://dbpedia.org/ontology/College$delta_old>(?X) .
        INSERT INTO "dbrdf_CollegeOrUniversity_delta_new"(s) SELECT t0.s FROM "dbrdf_College_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_CollegeOrUniversity" ex WHERE ex.s = t0.s);


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


        -- <http://dbpedia.org/ontology/University$delta_new>(?X) :- <http://schema.org/CollegeOrUniversity$delta_old>(?X) .
        INSERT INTO "dbrdf_University_delta_new"(s) SELECT t0.s FROM "dbrdf_CollegeOrUniversity_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_University0" ex WHERE ex.s = t0.s);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_College"(s) SELECT DISTINCT t0.s FROM "dbrdf_College_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_College_delta_old";
        INSERT INTO "dbrdf_College_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_College_delta_new" t0;
        TRUNCATE TABLE "dbrdf_College_delta_new";

        INSERT INTO "dbrdf_CollegeOrUniversity"(s) SELECT DISTINCT t0.s FROM "dbrdf_CollegeOrUniversity_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_CollegeOrUniversity_delta_old";
        INSERT INTO "dbrdf_CollegeOrUniversity_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_CollegeOrUniversity_delta_new" t0;
        TRUNCATE TABLE "dbrdf_CollegeOrUniversity_delta_new";

        INSERT INTO "dbrdf_University0"(s) SELECT DISTINCT t0.s FROM "dbrdf_University_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_University_delta_old";
        INSERT INTO "dbrdf_University_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_University_delta_new" t0;
        TRUNCATE TABLE "dbrdf_University_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1821
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_riverMouth_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_riverMouth_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_riverMouth" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_riverMouth_delta_old" ON "dbrdf_riverMouth_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_riverMouth_delta_old" ON "dbrdf_riverMouth_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_riverMouth_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1822
    ---- DEPENDS ON: 1821, 1783, 1750, 1646, 1376, 1369, 1238, 1228, 1092, 1055, 1041, 1018, 1011, 940, 871, 772, 710, 426, 386, 382, 243, 224, 1, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/River>(?X) :- <http://dbpedia.org/ontology/sourceConfluence>(?X,?X1) .
    INSERT INTO "dbrdf_River"(s) SELECT DISTINCT t0.s FROM "dbrdf_sourceConfluence" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_River" 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_RiverBodyOfWater_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_RiverBodyOfWater_delta_old"(s) SELECT t0.s FROM "dbrdf_RiverBodyOfWater" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_RiverBodyOfWater_delta_old" ON "dbrdf_RiverBodyOfWater_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_RiverBodyOfWater_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_River_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_River_delta_old"(s) SELECT t0.s 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);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_River_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://schema.org/RiverBodyOfWater$delta_new>(?X) :- <http://dbpedia.org/ontology/River$delta_old>(?X) .
        INSERT INTO "dbrdf_RiverBodyOfWater_delta_new"(s) SELECT t0.s FROM "dbrdf_River_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_RiverBodyOfWater" ex WHERE ex.s = t0.s);


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


        -- <http://dbpedia.org/ontology/River$delta_new>(?X) :- <http://schema.org/RiverBodyOfWater$delta_old>(?X) .
        INSERT INTO "dbrdf_River_delta_new"(s) SELECT t0.s FROM "dbrdf_RiverBodyOfWater_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_River" ex WHERE ex.s = t0.s);


        -- <http://dbpedia.org/ontology/River$delta_new>(?Y) :- <http://dbpedia.org/ontology/River$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_River_delta_new"(s) SELECT t1.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);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_RiverBodyOfWater"(s) SELECT DISTINCT t0.s FROM "dbrdf_RiverBodyOfWater_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_RiverBodyOfWater_delta_old";
        INSERT INTO "dbrdf_RiverBodyOfWater_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_RiverBodyOfWater_delta_new" t0;
        TRUNCATE TABLE "dbrdf_RiverBodyOfWater_delta_new";

        INSERT INTO "dbrdf_River"(s) SELECT DISTINCT t0.s 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) SELECT DISTINCT t0.s FROM "dbrdf_River_delta_new" t0;
        TRUNCATE TABLE "dbrdf_River_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1823
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_visitorsPercentageChange_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_visitorsPercentageChange_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_visitorsPercentageChange" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_visitorsPercentageChange_delta_old" ON "dbrdf_visitorsPercentageChange_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_visitorsPercentageChange_delta_old" ON "dbrdf_visitorsPercentageChange_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_visitorsPercentageChange_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1824
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_diameter3"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_diameter_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_diameter_delta_old3";
        INSERT INTO "dbrdf_diameter_delta_old3"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_diameter_delta_new3" t0;
        TRUNCATE TABLE "dbrdf_diameter_delta_new3";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1825
    ---- DEPENDS ON: 1824, 1811, 1511, 736, 187, 127, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Weapon>(?X) :- <http://dbpedia.org/ontology/Weapon/length>(?X,?X1) .
    INSERT INTO "dbrdf_Weapon"(s) SELECT DISTINCT t0.s FROM "dbrdf_length1" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Weapon" 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_Weapon_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Weapon_delta_old"(s) SELECT t0.s FROM "dbrdf_Weapon" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Weapon_delta_old" ON "dbrdf_Weapon_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Weapon_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/Weapon$delta_new>(?Y) :- <http://dbpedia.org/ontology/Weapon$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Weapon_delta_new"(s) SELECT t1.o FROM "dbrdf_Weapon_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Weapon" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Weapon"(s) SELECT DISTINCT t0.s FROM "dbrdf_Weapon_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Weapon_delta_old";
        INSERT INTO "dbrdf_Weapon_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Weapon_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Weapon_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1826
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_casSupplemental_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_casSupplemental_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_casSupplemental" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_casSupplemental_delta_old" ON "dbrdf_casSupplemental_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_casSupplemental_delta_old" ON "dbrdf_casSupplemental_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_casSupplemental_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1827
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_baftaAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_baftaAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_baftaAward" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_baftaAward_delta_old" ON "dbrdf_baftaAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_baftaAward_delta_old" ON "dbrdf_baftaAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_baftaAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1828
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_shoreLength0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_shoreLength_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_shoreLength_delta_old0";
        INSERT INTO "dbrdf_shoreLength_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_shoreLength_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_shoreLength_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1829
    ---- DEPENDS ON: 1828, 1508, 1369, 1304, 1233, 951, 799, 772, 561, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Lake>(?X) :- <http://dbpedia.org/ontology/frozen>(?X,?X1) .
    INSERT INTO "dbrdf_Lake"(s) SELECT DISTINCT t0.s FROM "dbrdf_frozen" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Lake" 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_LakeBodyOfWater_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_LakeBodyOfWater_delta_old"(s) SELECT t0.s FROM "dbrdf_LakeBodyOfWater" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_LakeBodyOfWater_delta_old" ON "dbrdf_LakeBodyOfWater_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_LakeBodyOfWater_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Lake_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Lake_delta_old"(s) SELECT t0.s FROM "dbrdf_Lake" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Lake_delta_old" ON "dbrdf_Lake_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Lake_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://schema.org/LakeBodyOfWater$delta_new>(?X) :- <http://dbpedia.org/ontology/Lake$delta_old>(?X) .
        INSERT INTO "dbrdf_LakeBodyOfWater_delta_new"(s) SELECT t0.s FROM "dbrdf_Lake_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_LakeBodyOfWater" ex WHERE ex.s = t0.s);


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


        -- <http://dbpedia.org/ontology/Lake$delta_new>(?X) :- <http://schema.org/LakeBodyOfWater$delta_old>(?X) .
        INSERT INTO "dbrdf_Lake_delta_new"(s) SELECT t0.s FROM "dbrdf_LakeBodyOfWater_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Lake" ex WHERE ex.s = t0.s);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_LakeBodyOfWater"(s) SELECT DISTINCT t0.s FROM "dbrdf_LakeBodyOfWater_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_LakeBodyOfWater_delta_old";
        INSERT INTO "dbrdf_LakeBodyOfWater_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_LakeBodyOfWater_delta_new" t0;
        TRUNCATE TABLE "dbrdf_LakeBodyOfWater_delta_new";

        INSERT INTO "dbrdf_Lake"(s) SELECT DISTINCT t0.s FROM "dbrdf_Lake_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Lake_delta_old";
        INSERT INTO "dbrdf_Lake_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Lake_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Lake_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1830
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_number_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_number_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_number" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_number_delta_old" ON "dbrdf_number_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_number_delta_old" ON "dbrdf_number_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_number_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1831
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_NationalSoccerClub"(s) SELECT DISTINCT t0.s FROM "dbrdf_NationalSoccerClub_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_NationalSoccerClub_delta_old";
        INSERT INTO "dbrdf_NationalSoccerClub_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_NationalSoccerClub_delta_new" t0;
        TRUNCATE TABLE "dbrdf_NationalSoccerClub_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1832
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_naacpImageAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_naacpImageAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_naacpImageAward" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_naacpImageAward_delta_old" ON "dbrdf_naacpImageAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_naacpImageAward_delta_old" ON "dbrdf_naacpImageAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_naacpImageAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1833
    ---- DEPENDS ON: 1581, 751, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- [Rule] <http://dbpedia.org/ontology/RadioStation>(?X) :- <http://dbpedia.org/ontology/airDate>(?X,?X1) .
    INSERT INTO "dbrdf_RadioStation0"(s) SELECT DISTINCT t0.s FROM "dbrdf_airDate" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_RadioStation0" 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_RadioStation_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_RadioStation_delta_old"(s) SELECT t0.s FROM "dbrdf_RadioStation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_RadioStation_delta_old" ON "dbrdf_RadioStation_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_RadioStation_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_RadioStation_delta_old0"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_RadioStation_delta_old0"(s) SELECT t0.s FROM "dbrdf_RadioStation0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_RadioStation_delta_old0" ON "dbrdf_RadioStation_delta_old0"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_RadioStation_delta_new0"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_RadioStation"(s) SELECT DISTINCT t0.s FROM "dbrdf_RadioStation_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_RadioStation_delta_old";
        INSERT INTO "dbrdf_RadioStation_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_RadioStation_delta_new" t0;
        TRUNCATE TABLE "dbrdf_RadioStation_delta_new";

        INSERT INTO "dbrdf_RadioStation0"(s) SELECT DISTINCT t0.s FROM "dbrdf_RadioStation_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_RadioStation_delta_old0";
        INSERT INTO "dbrdf_RadioStation_delta_old0"(s) SELECT DISTINCT t0.s FROM "dbrdf_RadioStation_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_RadioStation_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1834
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_perCapitaIncome_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_perCapitaIncome_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_perCapitaIncome" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_perCapitaIncome_delta_old" ON "dbrdf_perCapitaIncome_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_perCapitaIncome_delta_old" ON "dbrdf_perCapitaIncome_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_perCapitaIncome_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1835
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_setupTime_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_setupTime_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_setupTime" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_setupTime_delta_old" ON "dbrdf_setupTime_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_setupTime_delta_old" ON "dbrdf_setupTime_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_setupTime_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1836
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lunarModule_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lunarModule_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lunarModule" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lunarModule_delta_old" ON "dbrdf_lunarModule_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lunarModule_delta_old" ON "dbrdf_lunarModule_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lunarModule_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1837
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sport_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sport_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_sport" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sport_delta_old" ON "dbrdf_sport_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sport_delta_old" ON "dbrdf_sport_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sport_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1838
    ---- DEPENDS ON: 1837, 1706, 945, 511, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Sport"(s) SELECT DISTINCT t0.s FROM "dbrdf_Sport_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Sport_delta_old";
        INSERT INTO "dbrdf_Sport_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Sport_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Sport_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1839
    ---- DEPENDS ON: 680, 1838, 82, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

    -- [Rule] <http://dbpedia.org/ontology/Activity>(?X) :- <http://dbpedia.org/ontology/equipment>(?X,?X1) .
    INSERT INTO "dbrdf_Activity"(s) SELECT DISTINCT t0.s FROM "dbrdf_equipment" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Activity" 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_Activity_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Activity_delta_old"(s) SELECT t0.s FROM "dbrdf_Activity" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Activity_delta_old" ON "dbrdf_Activity_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Activity_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/Activity$delta_new>(?Y) :- <http://dbpedia.org/ontology/Activity$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Activity_delta_new"(s) SELECT t1.o FROM "dbrdf_Activity_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Activity" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Activity"(s) SELECT DISTINCT t0.s FROM "dbrdf_Activity_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Activity_delta_old";
        INSERT INTO "dbrdf_Activity_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Activity_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Activity_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1840
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_callsignMeaning_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_callsignMeaning_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_callsignMeaning" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_callsignMeaning_delta_old" ON "dbrdf_callsignMeaning_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_callsignMeaning_delta_old" ON "dbrdf_callsignMeaning_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_callsignMeaning_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1841
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_schoolCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_schoolCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_schoolCode" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_schoolCode_delta_old" ON "dbrdf_schoolCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_schoolCode_delta_old" ON "dbrdf_schoolCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_schoolCode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1842
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_regime_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_regime_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_regime" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_regime_delta_old" ON "dbrdf_regime_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_regime_delta_old" ON "dbrdf_regime_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_regime_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1843
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_timeshiftChannel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_timeshiftChannel_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_timeshiftChannel" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_timeshiftChannel_delta_old" ON "dbrdf_timeshiftChannel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_timeshiftChannel_delta_old" ON "dbrdf_timeshiftChannel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_timeshiftChannel_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1844
    ---- DEPENDS ON: 1843, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/TelevisionStation>(?X) :- <http://dbpedia.org/ontology/timeshiftChannel>(?X,?X1) .
    INSERT INTO "dbrdf_TelevisionStation0"(s) SELECT DISTINCT t0.s FROM "dbrdf_timeshiftChannel" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_TelevisionStation0" 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_TelevisionStation_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_TelevisionStation_delta_old"(s) SELECT t0.s FROM "dbrdf_TelevisionStation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_TelevisionStation_delta_old" ON "dbrdf_TelevisionStation_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_TelevisionStation_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_TelevisionStation_delta_old0"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_TelevisionStation_delta_old0"(s) SELECT t0.s FROM "dbrdf_TelevisionStation0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_TelevisionStation_delta_old0" ON "dbrdf_TelevisionStation_delta_old0"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_TelevisionStation_delta_new0"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_TelevisionStation"(s) SELECT DISTINCT t0.s FROM "dbrdf_TelevisionStation_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_TelevisionStation_delta_old";
        INSERT INTO "dbrdf_TelevisionStation_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_TelevisionStation_delta_new" t0;
        TRUNCATE TABLE "dbrdf_TelevisionStation_delta_new";

        INSERT INTO "dbrdf_TelevisionStation0"(s) SELECT DISTINCT t0.s FROM "dbrdf_TelevisionStation_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_TelevisionStation_delta_old0";
        INSERT INTO "dbrdf_TelevisionStation_delta_old0"(s) SELECT DISTINCT t0.s FROM "dbrdf_TelevisionStation_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_TelevisionStation_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1845
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_curator_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_curator_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_curator" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_curator_delta_old" ON "dbrdf_curator_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_curator_delta_old" ON "dbrdf_curator_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_curator_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1846
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_spike_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_spike_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_spike" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_spike_delta_old" ON "dbrdf_spike_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_spike_delta_old" ON "dbrdf_spike_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_spike_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1847
    ---- DEPENDS ON: 1846, 1255, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- [Rule] <http://dbpedia.org/ontology/VolleyballPlayer>(?X) :- <http://dbpedia.org/ontology/block>(?X,?X1) .
    INSERT INTO "dbrdf_VolleyballPlayer"(s) SELECT DISTINCT t0.s FROM "dbrdf_block" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_VolleyballPlayer" 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_VolleyballPlayer_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_VolleyballPlayer_delta_old"(s) SELECT t0.s FROM "dbrdf_VolleyballPlayer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_VolleyballPlayer_delta_old" ON "dbrdf_VolleyballPlayer_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_VolleyballPlayer_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/VolleyballPlayer$delta_new>(?Y) :- <http://dbpedia.org/ontology/VolleyballPlayer$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_VolleyballPlayer_delta_new"(s) SELECT t1.o FROM "dbrdf_VolleyballPlayer_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_VolleyballPlayer" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_VolleyballPlayer"(s) SELECT DISTINCT t0.s FROM "dbrdf_VolleyballPlayer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_VolleyballPlayer_delta_old";
        INSERT INTO "dbrdf_VolleyballPlayer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_VolleyballPlayer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_VolleyballPlayer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1848
    ---- DEPENDS ON: 918, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Hospital>(?X) :- <http://dbpedia.org/ontology/bedCount>(?X,?X1) .
    INSERT INTO "dbrdf_Hospital"(s) SELECT DISTINCT t0.s FROM "dbrdf_bedCount" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Hospital" 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_Hospital_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Hospital_delta_old"(s) SELECT t0.s FROM "dbrdf_Hospital" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Hospital_delta_old" ON "dbrdf_Hospital_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Hospital_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Hospital_delta_old0"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Hospital_delta_old0"(s) SELECT t0.s FROM "dbrdf_Hospital0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Hospital_delta_old0" ON "dbrdf_Hospital_delta_old0"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Hospital_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/Hospital$delta_new>(?X) :- <http://schema.org/Hospital$delta_old>(?X) .
        INSERT INTO "dbrdf_Hospital_delta_new"(s) SELECT t0.s FROM "dbrdf_Hospital_delta_old0" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Hospital" ex WHERE ex.s = t0.s);


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


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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Hospital"(s) SELECT DISTINCT t0.s FROM "dbrdf_Hospital_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Hospital_delta_old";
        INSERT INTO "dbrdf_Hospital_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Hospital_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Hospital_delta_new";

        INSERT INTO "dbrdf_Hospital0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Hospital_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_Hospital_delta_old0";
        INSERT INTO "dbrdf_Hospital_delta_old0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Hospital_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_Hospital_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1849
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_draftTeam_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_draftTeam_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_draftTeam" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_draftTeam_delta_old" ON "dbrdf_draftTeam_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_draftTeam_delta_old" ON "dbrdf_draftTeam_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_draftTeam_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1850
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_office_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_office_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_office" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_office_delta_old" ON "dbrdf_office_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_office_delta_old" ON "dbrdf_office_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_office_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1851
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_conservationStatus_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_conservationStatus_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_conservationStatus" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_conservationStatus_delta_old" ON "dbrdf_conservationStatus_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_conservationStatus_delta_old" ON "dbrdf_conservationStatus_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_conservationStatus_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1852
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_poleDriverCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_poleDriverCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_poleDriverCountry" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_poleDriverCountry_delta_old" ON "dbrdf_poleDriverCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_poleDriverCountry_delta_old" ON "dbrdf_poleDriverCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_poleDriverCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1853
    ---- DEPENDS ON: 1516, 1431, 1068, 842, 529, 161, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Protein>(?X) :- <http://dbpedia.org/ontology/locusSupplementaryData>(?X,?X1) .
    INSERT INTO "dbrdf_Protein"(s) SELECT DISTINCT t0.s FROM "dbrdf_locusSupplementaryData" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Protein" 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_Protein_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Protein_delta_old"(s) SELECT t0.s FROM "dbrdf_Protein" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Protein_delta_old" ON "dbrdf_Protein_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Protein_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/Protein$delta_new>(?Y) :- <http://dbpedia.org/ontology/Protein$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Protein_delta_new"(s) SELECT t1.o FROM "dbrdf_Protein_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Protein" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Protein"(s) SELECT DISTINCT t0.s FROM "dbrdf_Protein_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Protein_delta_old";
        INSERT INTO "dbrdf_Protein_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Protein_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Protein_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1854
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_trainerClub_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_trainerClub_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_trainerClub" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_trainerClub_delta_old" ON "dbrdf_trainerClub_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_trainerClub_delta_old" ON "dbrdf_trainerClub_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_trainerClub_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1855
    ---- DEPENDS ON: 1854, 1795, 1662, 1653, 1566, 1541, 1479, 1024, 857, 766, 460, 383, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/SoccerPlayer>(?X) :- <http://dbpedia.org/ontology/years>(?X,?X1) .
    INSERT INTO "dbrdf_SoccerPlayer"(s) SELECT DISTINCT t0.s FROM "dbrdf_years" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_SoccerPlayer" 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_SoccerPlayer_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SoccerPlayer_delta_old"(s) SELECT t0.s FROM "dbrdf_SoccerPlayer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SoccerPlayer_delta_old" ON "dbrdf_SoccerPlayer_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SoccerPlayer_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/SoccerPlayer$delta_new>(?Y) :- <http://dbpedia.org/ontology/SoccerPlayer$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_SoccerPlayer_delta_new"(s) SELECT t1.o FROM "dbrdf_SoccerPlayer_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_SoccerPlayer" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_SoccerPlayer"(s) SELECT DISTINCT t0.s FROM "dbrdf_SoccerPlayer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SoccerPlayer_delta_old";
        INSERT INTO "dbrdf_SoccerPlayer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SoccerPlayer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SoccerPlayer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1856
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_buildingEndDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_buildingEndDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_buildingEndDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_buildingEndDate_delta_old" ON "dbrdf_buildingEndDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_buildingEndDate_delta_old" ON "dbrdf_buildingEndDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_buildingEndDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1857
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_thirdDriverCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_thirdDriverCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_thirdDriverCountry" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_thirdDriverCountry_delta_old" ON "dbrdf_thirdDriverCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_thirdDriverCountry_delta_old" ON "dbrdf_thirdDriverCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_thirdDriverCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1858
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_fcRuns_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_fcRuns_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_fcRuns" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_fcRuns_delta_old" ON "dbrdf_fcRuns_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_fcRuns_delta_old" ON "dbrdf_fcRuns_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_fcRuns_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1859
    ---- DEPENDS ON: 1858, 111, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- [Rule] <http://dbpedia.org/ontology/Cricketer>(?X) :- <http://dbpedia.org/ontology/fc>(?X,?X1) .
    INSERT INTO "dbrdf_Cricketer"(s) SELECT DISTINCT t0.s FROM "dbrdf_fc" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Cricketer" 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_Cricketer_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Cricketer_delta_old"(s) SELECT t0.s FROM "dbrdf_Cricketer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Cricketer_delta_old" ON "dbrdf_Cricketer_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Cricketer_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/Cricketer$delta_new>(?Y) :- <http://dbpedia.org/ontology/Cricketer$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Cricketer_delta_new"(s) SELECT t1.o FROM "dbrdf_Cricketer_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Cricketer" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Cricketer"(s) SELECT DISTINCT t0.s FROM "dbrdf_Cricketer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Cricketer_delta_old";
        INSERT INTO "dbrdf_Cricketer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Cricketer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Cricketer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1860
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_headChef_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_headChef_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_headChef" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_headChef_delta_old" ON "dbrdf_headChef_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_headChef_delta_old" ON "dbrdf_headChef_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_headChef_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1861
    ---- DEPENDS ON: 1860, 881, 832, 444, 212, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Restaurant>(?X) :- <http://dbpedia.org/ontology/dressCode>(?X,?X1) .
    INSERT INTO "dbrdf_Restaurant0"(s) SELECT DISTINCT t0.s FROM "dbrdf_dressCode" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Restaurant0" 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_Restaurant_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Restaurant_delta_old"(s) SELECT t0.s FROM "dbrdf_Restaurant" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Restaurant_delta_old" ON "dbrdf_Restaurant_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Restaurant_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Restaurant_delta_old0"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Restaurant_delta_old0"(s) SELECT t0.s FROM "dbrdf_Restaurant0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Restaurant_delta_old0" ON "dbrdf_Restaurant_delta_old0"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Restaurant_delta_new0"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Restaurant"(s) SELECT DISTINCT t0.s FROM "dbrdf_Restaurant_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Restaurant_delta_old";
        INSERT INTO "dbrdf_Restaurant_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Restaurant_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Restaurant_delta_new";

        INSERT INTO "dbrdf_Restaurant0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Restaurant_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_Restaurant_delta_old0";
        INSERT INTO "dbrdf_Restaurant_delta_old0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Restaurant_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_Restaurant_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1862
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_musicalBand_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_musicalBand_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_musicalBand" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_musicalBand_delta_old" ON "dbrdf_musicalBand_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_musicalBand_delta_old" ON "dbrdf_musicalBand_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_musicalBand_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1863
    ---- DEPENDS ON: 1862, 1534, 353, 267, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Band>(?X) :- <http://dbpedia.org/ontology/bandMember>(?X,?X1) .
    INSERT INTO "dbrdf_Band"(s) SELECT DISTINCT t0.s FROM "dbrdf_bandMember" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Band" 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_Band_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Band_delta_old"(s) SELECT t0.s FROM "dbrdf_Band" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Band_delta_old" ON "dbrdf_Band_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Band_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/Band$delta_new>(?Y) :- <http://dbpedia.org/ontology/Band$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Band_delta_new"(s) SELECT t1.o FROM "dbrdf_Band_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Band" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Band"(s) SELECT DISTINCT t0.s FROM "dbrdf_Band_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Band_delta_old";
        INSERT INTO "dbrdf_Band_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Band_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Band_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1864
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_placeOfBurial_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_placeOfBurial_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_placeOfBurial" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_placeOfBurial_delta_old" ON "dbrdf_placeOfBurial_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_placeOfBurial_delta_old" ON "dbrdf_placeOfBurial_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_placeOfBurial_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1865
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_density_delta_old2"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_density_delta_old2"(s, o) SELECT t0.s, t0.o FROM "dbrdf_density2" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_density_delta_old2" ON "dbrdf_density_delta_old2"(s, o); CREATE INDEX "IDX_1_dbrdf_density_delta_old2" ON "dbrdf_density_delta_old2"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_density_delta_new2"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1866
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_oversight_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_oversight_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_oversight" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_oversight_delta_old" ON "dbrdf_oversight_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_oversight_delta_old" ON "dbrdf_oversight_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_oversight_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1867
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_frequency_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_frequency_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_frequency" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_frequency_delta_old" ON "dbrdf_frequency_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_frequency_delta_old" ON "dbrdf_frequency_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_frequency_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1868
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ruralMunicipality_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ruralMunicipality_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_ruralMunicipality" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ruralMunicipality_delta_old" ON "dbrdf_ruralMunicipality_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ruralMunicipality_delta_old" ON "dbrdf_ruralMunicipality_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ruralMunicipality_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1869
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ensembl_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ensembl_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_ensembl" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ensembl_delta_old" ON "dbrdf_ensembl_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ensembl_delta_old" ON "dbrdf_ensembl_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ensembl_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1870
    ---- DEPENDS ON: 1869, 1853, 1801, 1445, 1426, 1333, 1620, 986, 847, 744, 385, 380, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Biomolecule>(?X) :- <http://dbpedia.org/ontology/entrezgene>(?X,?X1) .
    INSERT INTO "dbrdf_Biomolecule"(s) SELECT DISTINCT t0.s FROM "dbrdf_entrezgene" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Biomolecule" 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_Biomolecule_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Biomolecule_delta_old"(s) SELECT t0.s FROM "dbrdf_Biomolecule" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Biomolecule_delta_old" ON "dbrdf_Biomolecule_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Biomolecule_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/Biomolecule$delta_new>(?Y) :- <http://dbpedia.org/ontology/Biomolecule$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Biomolecule_delta_new"(s) SELECT t1.o FROM "dbrdf_Biomolecule_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Biomolecule" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Biomolecule"(s) SELECT DISTINCT t0.s FROM "dbrdf_Biomolecule_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Biomolecule_delta_old";
        INSERT INTO "dbrdf_Biomolecule_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Biomolecule_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Biomolecule_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1871
    ---- DEPENDS ON: 672, 344, 341, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

    -- [Rule] <http://dbpedia.org/ontology/Royalty>(?X) :- <http://dbpedia.org/ontology/coronationDate>(?X,?X1) .
    INSERT INTO "dbrdf_Royalty"(s) SELECT DISTINCT t0.s FROM "dbrdf_coronationDate" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Royalty" 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_Royalty_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Royalty_delta_old"(s) SELECT t0.s FROM "dbrdf_Royalty" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Royalty_delta_old" ON "dbrdf_Royalty_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Royalty_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/Royalty$delta_new>(?Y) :- <http://dbpedia.org/ontology/Royalty$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Royalty_delta_new"(s) SELECT t1.o FROM "dbrdf_Royalty_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Royalty" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Royalty"(s) SELECT DISTINCT t0.s FROM "dbrdf_Royalty_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Royalty_delta_old";
        INSERT INTO "dbrdf_Royalty_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Royalty_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Royalty_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1872
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstDriver_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstDriver_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_firstDriver" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstDriver_delta_old" ON "dbrdf_firstDriver_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstDriver_delta_old" ON "dbrdf_firstDriver_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstDriver_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1873
    ---- DEPENDS ON: 1872, 1857, 1852, 1732, 1607, 1489, 1434, 1412, 1355, 1317, 1242, 1062, 964, 932, 909, 824, 800, 704, 663, 567, 564, 273, 113, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_GrandPrix"(s) SELECT DISTINCT t0.s FROM "dbrdf_GrandPrix_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_GrandPrix_delta_old";
        INSERT INTO "dbrdf_GrandPrix_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_GrandPrix_delta_new" t0;
        TRUNCATE TABLE "dbrdf_GrandPrix_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1874
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfCrew_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfCrew_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfCrew" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfCrew_delta_old" ON "dbrdf_numberOfCrew_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfCrew_delta_old" ON "dbrdf_numberOfCrew_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfCrew_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1875
    ---- DEPENDS ON: 1773, 1768, 1546, 1514, 793, 788, 661, 427, 138, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_WineRegion"(s) SELECT DISTINCT t0.s FROM "dbrdf_WineRegion_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_WineRegion_delta_old";
        INSERT INTO "dbrdf_WineRegion_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_WineRegion_delta_new" t0;
        TRUNCATE TABLE "dbrdf_WineRegion_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1876
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_goldMedalist_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_goldMedalist_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_goldMedalist" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_goldMedalist_delta_old" ON "dbrdf_goldMedalist_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_goldMedalist_delta_old" ON "dbrdf_goldMedalist_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_goldMedalist_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1877
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_museum_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_museum_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_museum" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_museum_delta_old" ON "dbrdf_museum_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_museum_delta_old" ON "dbrdf_museum_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_museum_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1878
    ---- DEPENDS ON: 1877, 879, 1267, 493, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Artwork>(?X) :- <http://dbpedia.org/ontology/painter>(?X,?X1) .
    INSERT INTO "dbrdf_Artwork"(s) SELECT DISTINCT t0.s FROM "dbrdf_painter" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Artwork" 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_Artwork_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Artwork_delta_old"(s) SELECT t0.s FROM "dbrdf_Artwork" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Artwork_delta_old" ON "dbrdf_Artwork_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Artwork_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/Artwork$delta_new>(?Y) :- <http://dbpedia.org/ontology/Artwork$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Artwork_delta_new"(s) SELECT t1.o FROM "dbrdf_Artwork_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Artwork" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Artwork"(s) SELECT DISTINCT t0.s FROM "dbrdf_Artwork_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Artwork_delta_old";
        INSERT INTO "dbrdf_Artwork_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Artwork_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Artwork_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1879
    ---- DEPENDS ON: 1877, 1845, 551, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

    -- [Rule] <http://dbpedia.org/ontology/Museum>(?X) :- <http://dbpedia.org/ontology/curator>(?X,?X1) .
    INSERT INTO "dbrdf_Museum0"(s) SELECT DISTINCT t0.s FROM "dbrdf_curator" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Museum0" 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_Museum_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Museum_delta_old"(s) SELECT t0.s FROM "dbrdf_Museum" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Museum_delta_old" ON "dbrdf_Museum_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Museum_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Museum_delta_old0"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Museum_delta_old0"(s) SELECT t0.s FROM "dbrdf_Museum0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Museum_delta_old0" ON "dbrdf_Museum_delta_old0"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Museum_delta_new0"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Museum"(s) SELECT DISTINCT t0.s FROM "dbrdf_Museum_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Museum_delta_old";
        INSERT INTO "dbrdf_Museum_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Museum_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Museum_delta_new";

        INSERT INTO "dbrdf_Museum0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Museum_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_Museum_delta_old0";
        INSERT INTO "dbrdf_Museum_delta_old0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Museum_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_Museum_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1880
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectObjective_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_projectObjective_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_projectObjective" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_projectObjective_delta_old" ON "dbrdf_projectObjective_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_projectObjective_delta_old" ON "dbrdf_projectObjective_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectObjective_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1881
    ---- DEPENDS ON: 1880, 1138, 1088, 781, 1606, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Project>(?X) :- <http://dbpedia.org/ontology/ResearchProject>(?X) .
    INSERT INTO "dbrdf_Project"(s) SELECT t0.s FROM "dbrdf_ResearchProject" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Project" 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_Project_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Project_delta_old"(s) SELECT t0.s FROM "dbrdf_Project" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Project_delta_old" ON "dbrdf_Project_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Project_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/Project$delta_new>(?Y) :- <http://dbpedia.org/ontology/Project$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Project_delta_new"(s) SELECT t1.o FROM "dbrdf_Project_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Project" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Project"(s) SELECT DISTINCT t0.s FROM "dbrdf_Project_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Project_delta_old";
        INSERT INTO "dbrdf_Project_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Project_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Project_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1882
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_tatoo_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_tatoo_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_tatoo" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_tatoo_delta_old" ON "dbrdf_tatoo_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_tatoo_delta_old" ON "dbrdf_tatoo_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_tatoo_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1883
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_notableCommander_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_notableCommander_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_notableCommander" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_notableCommander_delta_old" ON "dbrdf_notableCommander_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_notableCommander_delta_old" ON "dbrdf_notableCommander_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_notableCommander_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1884
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_grades_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_grades_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_grades" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_grades_delta_old" ON "dbrdf_grades_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_grades_delta_old" ON "dbrdf_grades_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_grades_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1885
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_distanceToCharingCross_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_distanceToCharingCross_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_distanceToCharingCross" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_distanceToCharingCross_delta_old" ON "dbrdf_distanceToCharingCross_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_distanceToCharingCross_delta_old" ON "dbrdf_distanceToCharingCross_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_distanceToCharingCross_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1886
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_brand_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_brand_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_brand" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_brand_delta_old" ON "dbrdf_brand_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_brand_delta_old" ON "dbrdf_brand_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_brand_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1887
    ---- DEPENDS ON: 1886, 1067, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- [Rule] <http://dbpedia.org/ontology/WrestlingEvent>(?X) :- <http://dbpedia.org/ontology/promotion>(?X,?X1) .
    INSERT INTO "dbrdf_WrestlingEvent"(s) SELECT DISTINCT t0.s FROM "dbrdf_promotion" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_WrestlingEvent" 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_WrestlingEvent_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_WrestlingEvent_delta_old"(s) SELECT t0.s FROM "dbrdf_WrestlingEvent" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_WrestlingEvent_delta_old" ON "dbrdf_WrestlingEvent_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_WrestlingEvent_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/WrestlingEvent$delta_new>(?Y) :- <http://dbpedia.org/ontology/WrestlingEvent$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_WrestlingEvent_delta_new"(s) SELECT t1.o FROM "dbrdf_WrestlingEvent_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_WrestlingEvent" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_WrestlingEvent"(s) SELECT DISTINCT t0.s FROM "dbrdf_WrestlingEvent_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_WrestlingEvent_delta_old";
        INSERT INTO "dbrdf_WrestlingEvent_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_WrestlingEvent_delta_new" t0;
        TRUNCATE TABLE "dbrdf_WrestlingEvent_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1888
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_extinctionDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_extinctionDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_extinctionDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_extinctionDate_delta_old" ON "dbrdf_extinctionDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_extinctionDate_delta_old" ON "dbrdf_extinctionDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_extinctionDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1889
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_countryWithFirstSpaceflight_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_countryWithFirstSpaceflight_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_countryWithFirstSpaceflight" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_countryWithFirstSpaceflight_delta_old" ON "dbrdf_countryWithFirstSpaceflight_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_countryWithFirstSpaceflight_delta_old" ON "dbrdf_countryWithFirstSpaceflight_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_countryWithFirstSpaceflight_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1890
    ---- DEPENDS ON: 1889, 1599, 1501, 1440, 1414, 1121, 1033, 767, 755, 657, 337, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/YearInSpaceflight>(?X) :- <http://dbpedia.org/ontology/retiredRocket>(?X,?X1) .
    INSERT INTO "dbrdf_YearInSpaceflight"(s) SELECT DISTINCT t0.s FROM "dbrdf_retiredRocket" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_YearInSpaceflight" 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_YearInSpaceflight_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_YearInSpaceflight_delta_old"(s) SELECT t0.s FROM "dbrdf_YearInSpaceflight" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_YearInSpaceflight_delta_old" ON "dbrdf_YearInSpaceflight_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_YearInSpaceflight_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/YearInSpaceflight$delta_new>(?Y) :- <http://dbpedia.org/ontology/YearInSpaceflight$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_YearInSpaceflight_delta_new"(s) SELECT t1.o FROM "dbrdf_YearInSpaceflight_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_YearInSpaceflight" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_YearInSpaceflight"(s) SELECT DISTINCT t0.s FROM "dbrdf_YearInSpaceflight_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_YearInSpaceflight_delta_old";
        INSERT INTO "dbrdf_YearInSpaceflight_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_YearInSpaceflight_delta_new" t0;
        TRUNCATE TABLE "dbrdf_YearInSpaceflight_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1891
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_censusYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_censusYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_censusYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_censusYear_delta_old" ON "dbrdf_censusYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_censusYear_delta_old" ON "dbrdf_censusYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_censusYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1892
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_club_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_club_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_club" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_club_delta_old" ON "dbrdf_club_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_club_delta_old" ON "dbrdf_club_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_club_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1893
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_HandballLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_HandballLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_HandballLeague_delta_old";
        INSERT INTO "dbrdf_HandballLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_HandballLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_HandballLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1894
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_academicDiscipline_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_academicDiscipline_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_academicDiscipline" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_academicDiscipline_delta_old" ON "dbrdf_academicDiscipline_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_academicDiscipline_delta_old" ON "dbrdf_academicDiscipline_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_academicDiscipline_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1895
    ---- DEPENDS ON: 1894, 1326, 738, 451, 352, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/AcademicJournal>(?X) :- <http://dbpedia.org/ontology/jstor>(?X,?X1) .
    INSERT INTO "dbrdf_AcademicJournal"(s) SELECT DISTINCT t0.s FROM "dbrdf_jstor" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_AcademicJournal" 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_AcademicJournal_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_AcademicJournal_delta_old"(s) SELECT t0.s FROM "dbrdf_AcademicJournal" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_AcademicJournal_delta_old" ON "dbrdf_AcademicJournal_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_AcademicJournal_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/AcademicJournal$delta_new>(?Y) :- <http://dbpedia.org/ontology/AcademicJournal$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_AcademicJournal_delta_new"(s) SELECT t1.o FROM "dbrdf_AcademicJournal_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_AcademicJournal" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_AcademicJournal"(s) SELECT DISTINCT t0.s FROM "dbrdf_AcademicJournal_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_AcademicJournal_delta_old";
        INSERT INTO "dbrdf_AcademicJournal_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_AcademicJournal_delta_new" t0;
        TRUNCATE TABLE "dbrdf_AcademicJournal_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1896
    ---- DEPENDS ON: 1785, 1467, 1220, 1895, 1140, 1032, 991, 937, 1694, 829, 1561, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/PeriodicalLiterature>(?X) :- <http://dbpedia.org/ontology/openAccessContent>(?X,?X1) .
    INSERT INTO "dbrdf_PeriodicalLiterature"(s) SELECT DISTINCT t0.s FROM "dbrdf_openAccessContent" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_PeriodicalLiterature" 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_PeriodicalLiterature_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_PeriodicalLiterature_delta_old"(s) SELECT t0.s FROM "dbrdf_PeriodicalLiterature" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_PeriodicalLiterature_delta_old" ON "dbrdf_PeriodicalLiterature_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_PeriodicalLiterature_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/PeriodicalLiterature$delta_new>(?Y) :- <http://dbpedia.org/ontology/PeriodicalLiterature$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_PeriodicalLiterature_delta_new"(s) SELECT t1.o FROM "dbrdf_PeriodicalLiterature_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_PeriodicalLiterature" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_PeriodicalLiterature"(s) SELECT DISTINCT t0.s FROM "dbrdf_PeriodicalLiterature_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_PeriodicalLiterature_delta_old";
        INSERT INTO "dbrdf_PeriodicalLiterature_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_PeriodicalLiterature_delta_new" t0;
        TRUNCATE TABLE "dbrdf_PeriodicalLiterature_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1897
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_flag_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_flag_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_flag" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_flag_delta_old" ON "dbrdf_flag_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_flag_delta_old" ON "dbrdf_flag_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_flag_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1898
    ---- DEPENDS ON: 1897, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Flag>(?X) :- <http://dbpedia.org/ontology/flag>(?X,?X1) .
    INSERT INTO "dbrdf_Flag"(s) SELECT DISTINCT t0.s FROM "dbrdf_flag" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Flag" 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_Flag_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Flag_delta_old"(s) SELECT t0.s FROM "dbrdf_Flag" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Flag_delta_old" ON "dbrdf_Flag_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Flag_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/Flag$delta_new>(?Y) :- <http://dbpedia.org/ontology/Flag$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Flag_delta_new"(s) SELECT t1.o FROM "dbrdf_Flag_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Flag" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Flag"(s) SELECT DISTINCT t0.s FROM "dbrdf_Flag_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Flag_delta_old";
        INSERT INTO "dbrdf_Flag_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Flag_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Flag_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1899
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_fate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_fate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_fate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_fate_delta_old" ON "dbrdf_fate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_fate_delta_old" ON "dbrdf_fate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_fate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1900
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_totalCargo_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_totalCargo_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_totalCargo" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_totalCargo_delta_old" ON "dbrdf_totalCargo_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_totalCargo_delta_old" ON "dbrdf_totalCargo_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_totalCargo_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1901
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_serviceEndDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_serviceEndDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_serviceEndDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_serviceEndDate_delta_old" ON "dbrdf_serviceEndDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_serviceEndDate_delta_old" ON "dbrdf_serviceEndDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_serviceEndDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1902
    ---- DEPENDS ON: 1901, 1794, 1766, 1553, 1318, 1076, 1054, 735, 713, 707, 682, 188, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/MilitaryPerson>(?X) :- <http://dbpedia.org/ontology/noteOnPlaceOfBurial>(?X,?X1) .
    INSERT INTO "dbrdf_MilitaryPerson"(s) SELECT DISTINCT t0.s FROM "dbrdf_noteOnPlaceOfBurial" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_MilitaryPerson" 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_MilitaryPerson_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_MilitaryPerson_delta_old"(s) SELECT t0.s FROM "dbrdf_MilitaryPerson" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_MilitaryPerson_delta_old" ON "dbrdf_MilitaryPerson_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_MilitaryPerson_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/MilitaryPerson$delta_new>(?Y) :- <http://dbpedia.org/ontology/MilitaryPerson$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_MilitaryPerson_delta_new"(s) SELECT t1.o FROM "dbrdf_MilitaryPerson_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_MilitaryPerson" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_MilitaryPerson"(s) SELECT DISTINCT t0.s FROM "dbrdf_MilitaryPerson_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_MilitaryPerson_delta_old";
        INSERT INTO "dbrdf_MilitaryPerson_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_MilitaryPerson_delta_new" t0;
        TRUNCATE TABLE "dbrdf_MilitaryPerson_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1903
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_minimumTemperature1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_minimumTemperature_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_minimumTemperature_delta_old1";
        INSERT INTO "dbrdf_minimumTemperature_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_minimumTemperature_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_minimumTemperature_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1904
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_stationEvaDuration0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_stationEvaDuration_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_stationEvaDuration_delta_old0";
        INSERT INTO "dbrdf_stationEvaDuration_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_stationEvaDuration_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_stationEvaDuration_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1905
    ---- DEPENDS ON: 1904, 1836, 1736, 1691, 1590, 1562, 1545, 1528, 1491, 1488, 1442, 1397, 1390, 1351, 1321, 1306, 1259, 1239, 1209, 1199, 1128, 1120, 1075, 1071, 1026, 916, 915, 869, 827, 804, 778, 732, 637, 635, 563, 555, 543, 499, 445, 415, 381, 336, 331, 294, 117, 50, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/SpaceMission>(?X) :- <http://dbpedia.org/ontology/launchPad>(?X,?X1) .
    INSERT INTO "dbrdf_SpaceMission"(s) SELECT DISTINCT t0.s FROM "dbrdf_launchPad" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_SpaceMission" 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_SpaceMission_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SpaceMission_delta_old"(s) SELECT t0.s FROM "dbrdf_SpaceMission" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SpaceMission_delta_old" ON "dbrdf_SpaceMission_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SpaceMission_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/SpaceMission$delta_new>(?Y) :- <http://dbpedia.org/ontology/SpaceMission$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_SpaceMission_delta_new"(s) SELECT t1.o FROM "dbrdf_SpaceMission_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_SpaceMission" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_SpaceMission"(s) SELECT DISTINCT t0.s FROM "dbrdf_SpaceMission_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SpaceMission_delta_old";
        INSERT INTO "dbrdf_SpaceMission_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SpaceMission_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SpaceMission_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1906
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_publisher_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_publisher_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_publisher" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_publisher_delta_old" ON "dbrdf_publisher_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_publisher_delta_old" ON "dbrdf_publisher_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_publisher_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1907
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_mass3"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_mass_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_mass_delta_old3";
        INSERT INTO "dbrdf_mass_delta_old3"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_mass_delta_new3" t0;
        TRUNCATE TABLE "dbrdf_mass_delta_new3";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1908
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_branchTo_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_branchTo_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_branchTo" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_branchTo_delta_old" ON "dbrdf_branchTo_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_branchTo_delta_old" ON "dbrdf_branchTo_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_branchTo_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1909
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_description_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_description_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_description" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_description_delta_old" ON "dbrdf_description_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_description_delta_old" ON "dbrdf_description_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_description_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1910
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_passengersPerDay_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_passengersPerDay_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_passengersPerDay" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_passengersPerDay_delta_old" ON "dbrdf_passengersPerDay_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_passengersPerDay_delta_old" ON "dbrdf_passengersPerDay_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_passengersPerDay_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1911
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_meaning_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_meaning_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_meaning" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_meaning_delta_old" ON "dbrdf_meaning_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_meaning_delta_old" ON "dbrdf_meaning_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_meaning_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1912
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_notableWine_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_notableWine_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_notableWine" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_notableWine_delta_old" ON "dbrdf_notableWine_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_notableWine_delta_old" ON "dbrdf_notableWine_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_notableWine_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1913
    ---- DEPENDS ON: 1912, 661, 138, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Grape"(s) SELECT DISTINCT t0.s FROM "dbrdf_Grape_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Grape_delta_old";
        INSERT INTO "dbrdf_Grape_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Grape_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Grape_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1914
    ---- DEPENDS ON: 1913, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/FloweringPlant>(?X) :- <http://dbpedia.org/ontology/Grape>(?X) .
    INSERT INTO "dbrdf_FloweringPlant"(s) SELECT t0.s FROM "dbrdf_Grape" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_FloweringPlant" 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_FloweringPlant_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_FloweringPlant_delta_old"(s) SELECT t0.s FROM "dbrdf_FloweringPlant" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_FloweringPlant_delta_old" ON "dbrdf_FloweringPlant_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_FloweringPlant_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/FloweringPlant$delta_new>(?Y) :- <http://dbpedia.org/ontology/FloweringPlant$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_FloweringPlant_delta_new"(s) SELECT t1.o FROM "dbrdf_FloweringPlant_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_FloweringPlant" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_FloweringPlant"(s) SELECT DISTINCT t0.s FROM "dbrdf_FloweringPlant_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_FloweringPlant_delta_old";
        INSERT INTO "dbrdf_FloweringPlant_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_FloweringPlant_delta_new" t0;
        TRUNCATE TABLE "dbrdf_FloweringPlant_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1915
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_floorArea0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_floorArea_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_floorArea_delta_old0";
        INSERT INTO "dbrdf_floorArea_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_floorArea_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_floorArea_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1916
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_chairman_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_chairman_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_chairman" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_chairman_delta_old" ON "dbrdf_chairman_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_chairman_delta_old" ON "dbrdf_chairman_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_chairman_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1917
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sisterStation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sisterStation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_sisterStation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sisterStation_delta_old" ON "dbrdf_sisterStation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sisterStation_delta_old" ON "dbrdf_sisterStation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sisterStation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1918
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_notableWork_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_notableWork_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_notableWork" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_notableWork_delta_old" ON "dbrdf_notableWork_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_notableWork_delta_old" ON "dbrdf_notableWork_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_notableWork_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1919
    ---- DEPENDS ON: 1918, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Writer>(?X) :- <http://dbpedia.org/ontology/notableWork>(?X,?X1) .
    INSERT INTO "dbrdf_Writer"(s) SELECT DISTINCT t0.s FROM "dbrdf_notableWork" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Writer" 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_Writer_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Writer_delta_old"(s) SELECT t0.s FROM "dbrdf_Writer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Writer_delta_old" ON "dbrdf_Writer_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Writer_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/Writer$delta_new>(?Y) :- <http://dbpedia.org/ontology/Writer$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Writer_delta_new"(s) SELECT t1.o FROM "dbrdf_Writer_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Writer" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Writer"(s) SELECT DISTINCT t0.s FROM "dbrdf_Writer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Writer_delta_old";
        INSERT INTO "dbrdf_Writer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Writer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Writer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1920
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_plant_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_plant_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_plant" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_plant_delta_old" ON "dbrdf_plant_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_plant_delta_old" ON "dbrdf_plant_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_plant_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1921
    ---- DEPENDS ON: 1920, 1786, 1914, 646, 614, 593, 538, 441, 242, 30, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Plant>(?X) :- <http://dbpedia.org/ontology/GreenAlga>(?X) .
    INSERT INTO "dbrdf_Plant"(s) SELECT t0.s FROM "dbrdf_GreenAlga" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Plant" 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_Plant_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Plant_delta_old"(s) SELECT t0.s FROM "dbrdf_Plant" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Plant_delta_old" ON "dbrdf_Plant_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Plant_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/Plant$delta_new>(?Y) :- <http://dbpedia.org/ontology/Plant$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Plant_delta_new"(s) SELECT t1.o FROM "dbrdf_Plant_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Plant" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Plant"(s) SELECT DISTINCT t0.s FROM "dbrdf_Plant_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Plant_delta_old";
        INSERT INTO "dbrdf_Plant_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Plant_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Plant_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1922
    ---- DEPENDS ON: 1712, 1921, 78, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Eukaryote"(s) SELECT DISTINCT t0.s FROM "dbrdf_Eukaryote_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Eukaryote_delta_old";
        INSERT INTO "dbrdf_Eukaryote_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Eukaryote_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Eukaryote_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1923
    ---- DEPENDS ON: 1851, 1922, 1629, 1393, 828, 725, 709, 699, 652, 549, 541, 531, 471, 288, 24, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Species>(?X) :- <http://dbpedia.org/ontology/Archaea>(?X) .
    INSERT INTO "dbrdf_Species"(s) SELECT t0.s FROM "dbrdf_Archaea" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Species" 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_Species_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Species_delta_old"(s) SELECT t0.s FROM "dbrdf_Species" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Species_delta_old" ON "dbrdf_Species_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Species_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/Species$delta_new>(?Y) :- <http://dbpedia.org/ontology/Species$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Species_delta_new"(s) SELECT t1.o FROM "dbrdf_Species_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Species" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Species"(s) SELECT DISTINCT t0.s FROM "dbrdf_Species_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Species_delta_old";
        INSERT INTO "dbrdf_Species_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Species_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Species_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1924
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtJapan_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtJapan_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_winsAtJapan" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtJapan_delta_old" ON "dbrdf_winsAtJapan_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtJapan_delta_old" ON "dbrdf_winsAtJapan_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtJapan_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1925
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_highestBuildingInYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_highestBuildingInYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_highestBuildingInYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_highestBuildingInYear_delta_old" ON "dbrdf_highestBuildingInYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_highestBuildingInYear_delta_old" ON "dbrdf_highestBuildingInYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_highestBuildingInYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1926
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_arrondissement_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_arrondissement_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_arrondissement" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_arrondissement_delta_old" ON "dbrdf_arrondissement_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_arrondissement_delta_old" ON "dbrdf_arrondissement_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_arrondissement_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1927
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ekatteCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ekatteCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_ekatteCode" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ekatteCode_delta_old" ON "dbrdf_ekatteCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ekatteCode_delta_old" ON "dbrdf_ekatteCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ekatteCode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1928
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_storyEditor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_storyEditor_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_storyEditor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_storyEditor_delta_old" ON "dbrdf_storyEditor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_storyEditor_delta_old" ON "dbrdf_storyEditor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_storyEditor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1929
    ---- DEPENDS ON: 1928, 1886, 1762, 1752, 1416, 1131, 1099, 903, 890, 708, 696, 517, 481, 290, 257, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/TelevisionShow>(?X) :- <http://dbpedia.org/ontology/presenter>(?X,?X1) .
