    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 1661
    ---- DEPENDS ON: 1660, 1658, 1616, 1230, 1078, 794, 277, 119, 98, 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/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/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/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;

    -- [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;

    -- 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 1662
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_course0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_course_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_course_delta_old0";
        INSERT INTO "dbrdf_course_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_course_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_course_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1663
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sourceCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_sourceCountry" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sourceCountry_delta_old" ON "dbrdf_sourceCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sourceCountry_delta_old" ON "dbrdf_sourceCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1664
    ---- 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 1665
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerChannel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_formerChannel_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_formerChannel" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_formerChannel_delta_old" ON "dbrdf_formerChannel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_formerChannel_delta_old" ON "dbrdf_formerChannel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerChannel_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1666
    ---- 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 1667
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_shuttle_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_shuttle_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_shuttle" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_shuttle_delta_old" ON "dbrdf_shuttle_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_shuttle_delta_old" ON "dbrdf_shuttle_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_shuttle_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1668
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1669
    ---- 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 1670
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_fastestDriverTeam_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_fastestDriverTeam_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_fastestDriverTeam" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_fastestDriverTeam_delta_old" ON "dbrdf_fastestDriverTeam_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_fastestDriverTeam_delta_old" ON "dbrdf_fastestDriverTeam_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_fastestDriverTeam_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1671
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1672
    ---- DEPENDS ON: 1202, 83, 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 1673
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1674
    ---- DEPENDS ON: 1673, 1291, 1207, 869, 824, 731, 463, 453, 248, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Airport>(?X) :- <http://dbpedia.org/ontology/faaLocationIdentifier>(?X,?X1) .
    INSERT INTO "dbrdf_Airport0"(s) SELECT DISTINCT t0.s FROM "dbrdf_faaLocationIdentifier" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Airport0" 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_Airport_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Airport_delta_old"(s) SELECT t0.s FROM "dbrdf_Airport" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Airport_delta_old" ON "dbrdf_Airport_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Airport_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Airport_delta_old0"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Airport_delta_old0"(s) SELECT t0.s FROM "dbrdf_Airport0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Airport_delta_old0" ON "dbrdf_Airport_delta_old0"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Airport_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/Airport$delta_new>(?X) :- <http://dbpedia.org/ontology/Airport$delta_old>(?X) .
        INSERT INTO "dbrdf_Airport_delta_new"(s) SELECT t0.s FROM "dbrdf_Airport_delta_old0" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Airport" ex WHERE ex.s = t0.s);


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


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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Airport"(s) SELECT DISTINCT t0.s FROM "dbrdf_Airport_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Airport_delta_old";
        INSERT INTO "dbrdf_Airport_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Airport_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Airport_delta_new";

        INSERT INTO "dbrdf_Airport0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Airport_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_Airport_delta_old0";
        INSERT INTO "dbrdf_Airport_delta_old0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Airport_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_Airport_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1675
    ---- DEPENDS ON: 1673, 1455, 1291, 556, 30, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Airline>(?X) :- <http://dbpedia.org/ontology/destination>(?X,?X1) .
    INSERT INTO "dbrdf_Airline"(s) SELECT DISTINCT t0.s FROM "dbrdf_destination" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Airline" 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_Airline_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Airline_delta_old"(s) SELECT t0.s FROM "dbrdf_Airline" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Airline_delta_old" ON "dbrdf_Airline_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Airline_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/Airline$delta_new>(?Y) :- <http://dbpedia.org/ontology/Airline$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Airline_delta_new"(s) SELECT t1.o FROM "dbrdf_Airline_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Airline" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Airline"(s) SELECT DISTINCT t0.s FROM "dbrdf_Airline_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Airline_delta_old";
        INSERT INTO "dbrdf_Airline_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Airline_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Airline_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1676
    ---- 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 1677
    ---- 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 1678
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_currentPartner_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_currentPartner_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_currentPartner" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_currentPartner_delta_old" ON "dbrdf_currentPartner_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_currentPartner_delta_old" ON "dbrdf_currentPartner_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_currentPartner_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1679
    ---- DEPENDS ON: 1678, 1096, 658, 342, 294, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/FigureSkater>(?X) :- <http://dbpedia.org/ontology/formerChoreographer>(?X,?X1) .
    INSERT INTO "dbrdf_FigureSkater"(s) SELECT DISTINCT t0.s FROM "dbrdf_formerChoreographer" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_FigureSkater" 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_FigureSkater_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_FigureSkater_delta_old"(s) SELECT t0.s FROM "dbrdf_FigureSkater" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_FigureSkater_delta_old" ON "dbrdf_FigureSkater_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_FigureSkater_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/FigureSkater$delta_new>(?Y) :- <http://dbpedia.org/ontology/FigureSkater$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_FigureSkater_delta_new"(s) SELECT t1.o FROM "dbrdf_FigureSkater_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_FigureSkater" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_FigureSkater"(s) SELECT DISTINCT t0.s FROM "dbrdf_FigureSkater_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_FigureSkater_delta_old";
        INSERT INTO "dbrdf_FigureSkater_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_FigureSkater_delta_new" t0;
        TRUNCATE TABLE "dbrdf_FigureSkater_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1680
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_routeDirection_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_routeDirection_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_routeDirection" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_routeDirection_delta_old" ON "dbrdf_routeDirection_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_routeDirection_delta_old" ON "dbrdf_routeDirection_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_routeDirection_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1681
    ---- 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 1682
    ---- DEPENDS ON: 1681, 1490, 1431, 269, 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 1683
    ---- DEPENDS ON: 1682, 202, 22, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [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;

    -- [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;

    -- 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 1684
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rival_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rival_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_rival" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rival_delta_old" ON "dbrdf_rival_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rival_delta_old" ON "dbrdf_rival_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rival_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1685
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_recordLabel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_recordLabel_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_recordLabel" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_recordLabel_delta_old" ON "dbrdf_recordLabel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_recordLabel_delta_old" ON "dbrdf_recordLabel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_recordLabel_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1686
    ---- DEPENDS ON: 1685, 1347, 600, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/RecordLabel>(?X) :- <http://dbpedia.org/ontology/distributingLabel>(?X,?X1) .
    INSERT INTO "dbrdf_RecordLabel"(s) SELECT DISTINCT t0.s FROM "dbrdf_distributingLabel" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_RecordLabel" 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_RecordLabel_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_RecordLabel_delta_old"(s) SELECT t0.s FROM "dbrdf_RecordLabel" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_RecordLabel_delta_old" ON "dbrdf_RecordLabel_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_RecordLabel_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/RecordLabel$delta_new>(?Y) :- <http://dbpedia.org/ontology/RecordLabel$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_RecordLabel_delta_new"(s) SELECT t1.o FROM "dbrdf_RecordLabel_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_RecordLabel" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_RecordLabel"(s) SELECT DISTINCT t0.s FROM "dbrdf_RecordLabel_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_RecordLabel_delta_old";
        INSERT INTO "dbrdf_RecordLabel_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_RecordLabel_delta_new" t0;
        TRUNCATE TABLE "dbrdf_RecordLabel_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1687
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_actingHeadteacher_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_actingHeadteacher_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_actingHeadteacher" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_actingHeadteacher_delta_old" ON "dbrdf_actingHeadteacher_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_actingHeadteacher_delta_old" ON "dbrdf_actingHeadteacher_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_actingHeadteacher_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1688
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_functionEndYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_functionEndYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_functionEndYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_functionEndYear_delta_old" ON "dbrdf_functionEndYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_functionEndYear_delta_old" ON "dbrdf_functionEndYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_functionEndYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1689
    ---- 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 1690
    ---- 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 1691
    ---- 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 1692
    ---- DEPENDS ON: 1691, 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 1693
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastRace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lastRace_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lastRace" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lastRace_delta_old" ON "dbrdf_lastRace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lastRace_delta_old" ON "dbrdf_lastRace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastRace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1694
    ---- 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 1695
    ---- 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 1696
    ---- DEPENDS ON: 1695, 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 1697
    ---- 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 1698
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_afdbId_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_afdbId_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_afdbId" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_afdbId_delta_old" ON "dbrdf_afdbId_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_afdbId_delta_old" ON "dbrdf_afdbId_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_afdbId_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1699
    ---- 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 1700
    ---- DEPENDS ON: 1699, 1299, 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 1701
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1702
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_spouse_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_spouse_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_spouse" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_spouse_delta_old" ON "dbrdf_spouse_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_spouse_delta_old" ON "dbrdf_spouse_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_spouse_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1703
    ---- DEPENDS ON: 706, 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 1704
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftElectronic_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftElectronic_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_aircraftElectronic" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftElectronic_delta_old" ON "dbrdf_aircraftElectronic_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftElectronic_delta_old" ON "dbrdf_aircraftElectronic_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftElectronic_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1705
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_orbitalPeriod_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_orbitalPeriod_delta_old1"(s, o) SELECT t0.s, t0.o FROM "dbrdf_orbitalPeriod1" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_orbitalPeriod_delta_old1" ON "dbrdf_orbitalPeriod_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_orbitalPeriod_delta_old1" ON "dbrdf_orbitalPeriod_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_orbitalPeriod_delta_new1"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_orbitalPeriod1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_orbitalPeriod_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_orbitalPeriod_delta_old1";
        INSERT INTO "dbrdf_orbitalPeriod_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_orbitalPeriod_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_orbitalPeriod_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1706
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsGroup_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_alpsGroup_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_alpsGroup" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_alpsGroup_delta_old" ON "dbrdf_alpsGroup_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_alpsGroup_delta_old" ON "dbrdf_alpsGroup_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsGroup_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1707
    ---- DEPENDS ON: 1706, 1544, 1423, 1361, 1304, 1043, 891, 266, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/MountainRange>(?X1) :- <http://dbpedia.org/ontology/alpsSection>(?X,?X1) .
    INSERT INTO "dbrdf_MountainRange"(s) SELECT DISTINCT t0.o FROM "dbrdf_alpsSection" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_MountainRange" 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_MountainRange_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_MountainRange_delta_old"(s) SELECT t0.s FROM "dbrdf_MountainRange" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_MountainRange_delta_old" ON "dbrdf_MountainRange_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_MountainRange_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/MountainRange$delta_new>(?Y) :- <http://dbpedia.org/ontology/MountainRange$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_MountainRange_delta_new"(s) SELECT t1.o FROM "dbrdf_MountainRange_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_MountainRange" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_MountainRange"(s) SELECT DISTINCT t0.s FROM "dbrdf_MountainRange_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_MountainRange_delta_old";
        INSERT INTO "dbrdf_MountainRange_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_MountainRange_delta_new" t0;
        TRUNCATE TABLE "dbrdf_MountainRange_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1708
    ---- 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 1709
    ---- 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 1710
    ---- 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 1711
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_leftChild_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_leftChild_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_leftChild" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_leftChild_delta_old" ON "dbrdf_leftChild_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_leftChild_delta_old" ON "dbrdf_leftChild_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_leftChild_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1712
    ---- 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 1713
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dateAct_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dateAct_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_dateAct" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dateAct_delta_old" ON "dbrdf_dateAct_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dateAct_delta_old" ON "dbrdf_dateAct_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dateAct_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1714
    ---- DEPENDS ON: 1713, 1558, 1489, 1466, 1373, 1340, 1288, 1218, 1127, 1020, 974, 927, 799, 700, 693, 683, 644, 526, 9, 3, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Canal>(?X) :- <http://dbpedia.org/ontology/Canal/originalMaximumBoatBeam>(?X,?X1) .
    INSERT INTO "dbrdf_Canal0"(s) SELECT DISTINCT t0.s FROM "dbrdf_originalMaximumBoatBeam" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Canal0" 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_Canal_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Canal_delta_old"(s) SELECT t0.s FROM "dbrdf_Canal" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Canal_delta_old" ON "dbrdf_Canal_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Canal_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Canal_delta_old0"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Canal_delta_old0"(s) SELECT t0.s FROM "dbrdf_Canal0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Canal_delta_old0" ON "dbrdf_Canal_delta_old0"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Canal_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/Canal$delta_new>(?X) :- <http://dbpedia.org/ontology/Canal$delta_old>(?X) .
        INSERT INTO "dbrdf_Canal_delta_new"(s) SELECT t0.s FROM "dbrdf_Canal_delta_old0" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Canal" ex WHERE ex.s = t0.s);


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


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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Canal"(s) SELECT DISTINCT t0.s FROM "dbrdf_Canal_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Canal_delta_old";
        INSERT INTO "dbrdf_Canal_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Canal_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Canal_delta_new";

        INSERT INTO "dbrdf_Canal0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Canal_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_Canal_delta_old0";
        INSERT INTO "dbrdf_Canal_delta_old0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Canal_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_Canal_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1715
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_introductionDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_introductionDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_introductionDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_introductionDate_delta_old" ON "dbrdf_introductionDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_introductionDate_delta_old" ON "dbrdf_introductionDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_introductionDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1716
    ---- 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 1717
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_month_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_month_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_month" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_month_delta_old" ON "dbrdf_month_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_month_delta_old" ON "dbrdf_month_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_month_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1718
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_foundationPlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_foundationPlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_foundationPlace" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_foundationPlace_delta_old" ON "dbrdf_foundationPlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_foundationPlace_delta_old" ON "dbrdf_foundationPlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_foundationPlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1719
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_overallRecord_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_overallRecord_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_overallRecord" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_overallRecord_delta_old" ON "dbrdf_overallRecord_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_overallRecord_delta_old" ON "dbrdf_overallRecord_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_overallRecord_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1720
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_bridgeCarries_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_bridgeCarries_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_bridgeCarries" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_bridgeCarries_delta_old" ON "dbrdf_bridgeCarries_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_bridgeCarries_delta_old" ON "dbrdf_bridgeCarries_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_bridgeCarries_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1721
    ---- DEPENDS ON: 1720, 1508, 751, 648, 578, 542, 389, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Bridge>(?X) :- <http://dbpedia.org/ontology/crosses>(?X,?X1) .
    INSERT INTO "dbrdf_Bridge"(s) SELECT DISTINCT t0.s FROM "dbrdf_crosses" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Bridge" 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_Bridge_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Bridge_delta_old"(s) SELECT t0.s FROM "dbrdf_Bridge" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Bridge_delta_old" ON "dbrdf_Bridge_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Bridge_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/Bridge$delta_new>(?Y) :- <http://dbpedia.org/ontology/Bridge$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Bridge_delta_new"(s) SELECT t1.o FROM "dbrdf_Bridge_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Bridge" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Bridge"(s) SELECT DISTINCT t0.s FROM "dbrdf_Bridge_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Bridge_delta_old";
        INSERT INTO "dbrdf_Bridge_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Bridge_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Bridge_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1722
    ---- DEPENDS ON: 1537, 1401, 978, 442, 424, 164, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [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/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/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;

    -- [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;

    -- 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 1723
    ---- 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 1724
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_creatorOfDish_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_creatorOfDish_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_creatorOfDish" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_creatorOfDish_delta_old" ON "dbrdf_creatorOfDish_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_creatorOfDish_delta_old" ON "dbrdf_creatorOfDish_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_creatorOfDish_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1725
    ---- 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 1726
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_lowerEarthOrbitPayload0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lowerEarthOrbitPayload_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_lowerEarthOrbitPayload_delta_old0";
        INSERT INTO "dbrdf_lowerEarthOrbitPayload_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lowerEarthOrbitPayload_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_lowerEarthOrbitPayload_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1727
    ---- 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 1728
    ---- 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 1729
    ---- DEPENDS ON: 1728, 307, 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 1730
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_child_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_child_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_child" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_child_delta_old" ON "dbrdf_child_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_child_delta_old" ON "dbrdf_child_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_child_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1731
    ---- 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 1732
    ---- DEPENDS ON: 1731, 1262, 614, 544, 211, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [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/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/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;

    -- [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;

    -- 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 1733
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_elementAbove_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_elementAbove_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_elementAbove" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_elementAbove_delta_old" ON "dbrdf_elementAbove_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_elementAbove_delta_old" ON "dbrdf_elementAbove_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_elementAbove_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1734
    ---- DEPENDS ON: 1733, 1425, 1378, 423, 293, 113, 1165, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/ChemicalSubstance>(?X) :- <http://dbpedia.org/ontology/ChemicalCompound>(?X) .
    INSERT INTO "dbrdf_ChemicalSubstance"(s) SELECT t0.s FROM "dbrdf_ChemicalCompound" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_ChemicalSubstance" 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_ChemicalSubstance_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ChemicalSubstance_delta_old"(s) SELECT t0.s FROM "dbrdf_ChemicalSubstance" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ChemicalSubstance_delta_old" ON "dbrdf_ChemicalSubstance_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ChemicalSubstance_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/ChemicalSubstance$delta_new>(?Y) :- <http://dbpedia.org/ontology/ChemicalSubstance$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_ChemicalSubstance_delta_new"(s) SELECT t1.o FROM "dbrdf_ChemicalSubstance_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_ChemicalSubstance" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_ChemicalSubstance"(s) SELECT DISTINCT t0.s FROM "dbrdf_ChemicalSubstance_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_ChemicalSubstance_delta_old";
        INSERT INTO "dbrdf_ChemicalSubstance_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_ChemicalSubstance_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ChemicalSubstance_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1735
    ---- 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 1736
    ---- DEPENDS ON: 1735, 1526, 979, 677, 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/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>(?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>(?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 1737
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1738
    ---- 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 1739
    ---- 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 1740
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1741
    ---- DEPENDS ON: 1740, 1175, 911, 878, 510, 432, 425, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/SoccerTournament>(?X1) :- <http://dbpedia.org/ontology/soccerTournamentThisSeason>(?X,?X1) .
    INSERT INTO "dbrdf_SoccerTournament"(s) SELECT DISTINCT t0.o FROM "dbrdf_soccerTournamentThisSeason" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_SoccerTournament" 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_SoccerTournament_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SoccerTournament_delta_old"(s) SELECT t0.s FROM "dbrdf_SoccerTournament" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SoccerTournament_delta_old" ON "dbrdf_SoccerTournament_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SoccerTournament_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/SoccerTournament$delta_new>(?Y) :- <http://dbpedia.org/ontology/SoccerTournament$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_SoccerTournament_delta_new"(s) SELECT t1.o FROM "dbrdf_SoccerTournament_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_SoccerTournament" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_SoccerTournament"(s) SELECT DISTINCT t0.s FROM "dbrdf_SoccerTournament_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SoccerTournament_delta_old";
        INSERT INTO "dbrdf_SoccerTournament_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SoccerTournament_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SoccerTournament_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1742
    ---- 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 1743
    ---- DEPENDS ON: 1637, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/SimilarAlbums>(?X0,?X2) :- <http://dbpedia.org/ontology/albumHasGenre>(?X0,?X1), <http://dbpedia.org/ontology/albumHasGenre>(?X2,?X1) .
    INSERT INTO "dbrdf_SimilarAlbums"(s, o) SELECT DISTINCT t0.s, t1.s FROM "dbrdf_albumHasGenre" t0, "dbrdf_albumHasGenre" t1 WHERE t0.o = t1.o AND NOT EXISTS (SELECT 1 FROM "dbrdf_SimilarAlbums" ex WHERE ex.s = t0.s AND ex.o = t1.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_SimilarAlbums_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SimilarAlbums_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_SimilarAlbums" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SimilarAlbums_delta_old" ON "dbrdf_SimilarAlbums_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_SimilarAlbums_delta_old" ON "dbrdf_SimilarAlbums_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SimilarAlbums_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1744
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_artist_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_artist_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_artist" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_artist_delta_old" ON "dbrdf_artist_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_artist_delta_old" ON "dbrdf_artist_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_artist_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/artist$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/artist$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        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 1745
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_omim_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_omim_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_omim" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_omim_delta_old" ON "dbrdf_omim_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_omim_delta_old" ON "dbrdf_omim_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_omim_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1746
    ---- 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 1747
    ---- 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 1748
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_largestWin_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_largestWin_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_largestWin" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_largestWin_delta_old" ON "dbrdf_largestWin_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_largestWin_delta_old" ON "dbrdf_largestWin_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_largestWin_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1749
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mouthElevation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mouthElevation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_mouthElevation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mouthElevation_delta_old" ON "dbrdf_mouthElevation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mouthElevation_delta_old" ON "dbrdf_mouthElevation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mouthElevation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1750
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_capitalPlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_capitalPlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_capitalPlace" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_capitalPlace_delta_old" ON "dbrdf_capitalPlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_capitalPlace_delta_old" ON "dbrdf_capitalPlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_capitalPlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1751
    ---- 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 1752
    ---- DEPENDS ON: 1751, 1745, 1722, 1088, 1071, 996, 963, 902, 832, 1274, 315, 205, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [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/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/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/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/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/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/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/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/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 1753
    ---- DEPENDS ON: 953, 945, 554, 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 1754
    ---- 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 1755
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_demonym_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_demonym_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_demonym" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_demonym_delta_old" ON "dbrdf_demonym_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_demonym_delta_old" ON "dbrdf_demonym_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_demonym_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1756
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_alias_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_alias_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_alias" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_alias_delta_old" ON "dbrdf_alias_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_alias_delta_old" ON "dbrdf_alias_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_alias_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1757
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_anniversary_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_anniversary_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_anniversary" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_anniversary_delta_old" ON "dbrdf_anniversary_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_anniversary_delta_old" ON "dbrdf_anniversary_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_anniversary_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1758
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_gaelicName_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_gaelicName_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_gaelicName" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_gaelicName_delta_old" ON "dbrdf_gaelicName_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_gaelicName_delta_old" ON "dbrdf_gaelicName_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_gaelicName_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1759
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ceo_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ceo_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_ceo" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ceo_delta_old" ON "dbrdf_ceo_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ceo_delta_old" ON "dbrdf_ceo_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ceo_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1760
    ---- DEPENDS ON: 1555, 1546, 1377, 1210, 1151, 384, 362, 114, 13, 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/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/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/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 1761
    ---- 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 1762
    ---- 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 1763
    ---- DEPENDS ON: 1762, 1418, 1167, 1293, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [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;

    -- [Rule] <http://dbpedia.org/ontology/Artwork>(?X) :- <http://dbpedia.org/ontology/Sculpture>(?X) .
    INSERT INTO "dbrdf_Artwork"(s) SELECT t0.s FROM "dbrdf_Sculpture" 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;

    -- 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 1764
    ---- DEPENDS ON: 1762, 1697, 1626, 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 1765
    ---- 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 1766
    ---- DEPENDS ON: 1765, 750, 675, 540, 1590, 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/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;

    -- [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;

    -- 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 1767
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfVisitorsAsOf_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfVisitorsAsOf_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfVisitorsAsOf" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfVisitorsAsOf_delta_old" ON "dbrdf_numberOfVisitorsAsOf_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfVisitorsAsOf_delta_old" ON "dbrdf_numberOfVisitorsAsOf_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfVisitorsAsOf_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1768
    ---- 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 1769
    ---- 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 1770
    ---- 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 1771
    ---- 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 1772
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_bloodType_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_bloodType_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_bloodType" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_bloodType_delta_old" ON "dbrdf_bloodType_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_bloodType_delta_old" ON "dbrdf_bloodType_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_bloodType_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1773
    ---- 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 1774
    ---- DEPENDS ON: 1773, 441, 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 1775
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_giniCoefficientAsOf_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_giniCoefficientAsOf_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_giniCoefficientAsOf" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_giniCoefficientAsOf_delta_old" ON "dbrdf_giniCoefficientAsOf_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_giniCoefficientAsOf_delta_old" ON "dbrdf_giniCoefficientAsOf_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_giniCoefficientAsOf_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1776
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_playingTime_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_playingTime_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_playingTime" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_playingTime_delta_old" ON "dbrdf_playingTime_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_playingTime_delta_old" ON "dbrdf_playingTime_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_playingTime_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1777
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_patron_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_patron_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_patron" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_patron_delta_old" ON "dbrdf_patron_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_patron_delta_old" ON "dbrdf_patron_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_patron_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1778
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mouthMountain_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mouthMountain_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_mouthMountain" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mouthMountain_delta_old" ON "dbrdf_mouthMountain_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mouthMountain_delta_old" ON "dbrdf_mouthMountain_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mouthMountain_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1779
    ---- DEPENDS ON: 1778, 1650, 1616, 1574, 1501, 1384, 1325, 1205, 1092, 1090, 1083, 1074, 898, 793, 702, 682, 619, 578, 418, 359, 199, 98, 1, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [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>(?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/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/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/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/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/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/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/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/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/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>(?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>(?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 1780
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_releaseDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_releaseDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_releaseDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_releaseDate_delta_old" ON "dbrdf_releaseDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_releaseDate_delta_old" ON "dbrdf_releaseDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_releaseDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1781
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_buildingStartYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_buildingStartYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_buildingStartYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_buildingStartYear_delta_old" ON "dbrdf_buildingStartYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_buildingStartYear_delta_old" ON "dbrdf_buildingStartYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_buildingStartYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1782
    ---- 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 1783
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_coachedTeam_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_coachedTeam_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_coachedTeam" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_coachedTeam_delta_old" ON "dbrdf_coachedTeam_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_coachedTeam_delta_old" ON "dbrdf_coachedTeam_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_coachedTeam_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1784
    ---- DEPENDS ON: 1783, 1719, 1564, 1499, 1483, 665, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/CollegeCoach>(?X) :- <http://dbpedia.org/ontology/tournamentRecord>(?X,?X1) .
    INSERT INTO "dbrdf_CollegeCoach"(s) SELECT DISTINCT t0.s FROM "dbrdf_tournamentRecord" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_CollegeCoach" 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_CollegeCoach_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_CollegeCoach_delta_old"(s) SELECT t0.s FROM "dbrdf_CollegeCoach" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_CollegeCoach_delta_old" ON "dbrdf_CollegeCoach_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_CollegeCoach_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/CollegeCoach$delta_new>(?Y) :- <http://dbpedia.org/ontology/CollegeCoach$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_CollegeCoach_delta_new"(s) SELECT t1.o FROM "dbrdf_CollegeCoach_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_CollegeCoach" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_CollegeCoach"(s) SELECT DISTINCT t0.s FROM "dbrdf_CollegeCoach_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_CollegeCoach_delta_old";
        INSERT INTO "dbrdf_CollegeCoach_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_CollegeCoach_delta_new" t0;
        TRUNCATE TABLE "dbrdf_CollegeCoach_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1785
    ---- 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 1786
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_foundingPerson_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_foundingPerson_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_foundingPerson" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_foundingPerson_delta_old" ON "dbrdf_foundingPerson_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_foundingPerson_delta_old" ON "dbrdf_foundingPerson_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_foundingPerson_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1787
    ---- 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 1788
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1789
    ---- 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 1790
    ---- 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 1791
    ---- 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 1792
    ---- DEPENDS ON: 1791, 1284, 977, 822, 346, 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/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/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/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 1793
    ---- DEPENDS ON: 1577, 1571, 1232, 1028, 1006, 1169, 667, 1792, 456, 327, 1415, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [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/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/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/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/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;

    -- [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;

    -- 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 1794
    ---- DEPENDS ON: 1723, 1597, 1379, 1353, 1338, 1330, 1317, 1183, 1175, 1084, 1044, 179, 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/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/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/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;

    -- [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;

    -- 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 1795
    ---- 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 1796
    ---- DEPENDS ON: 1795, 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 1797
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftTransport_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftTransport_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_aircraftTransport" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftTransport_delta_old" ON "dbrdf_aircraftTransport_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftTransport_delta_old" ON "dbrdf_aircraftTransport_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftTransport_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1798
    ---- 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;
