        TRUNCATE TABLE "dbrdf_Crustacean_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1471
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1472
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1473
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1474
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1475
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1476
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_slogan_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_slogan_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27966;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_slogan_delta_old" ON "dbrdf_slogan_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_slogan_delta_old" ON "dbrdf_slogan_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_slogan_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/slogan$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/slogan$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_slogan_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_slogan_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27966 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/slogan$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/slogan$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_slogan_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_slogan_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27966 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27966, t0.o FROM "dbrdf_slogan_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_slogan_delta_old";
        INSERT INTO "dbrdf_slogan_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_slogan_delta_new" t0;
        TRUNCATE TABLE "dbrdf_slogan_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1477
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1478
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1479
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1480
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_AustralianFootballLeague_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_AustralianFootballLeague_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27970;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_AustralianFootballLeague_delta_old" ON "dbrdf_AustralianFootballLeague_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_AustralianFootballLeague_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27970 FROM "dbrdf_AustralianFootballLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_AustralianFootballLeague_delta_old";
        INSERT INTO "dbrdf_AustralianFootballLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_AustralianFootballLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_AustralianFootballLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1481
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1482
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1483
    ---- 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 "__triples" t0 WHERE t0.p = 27973;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27973 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27973 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27973, 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 1484
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1485
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1486
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1487
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1488
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1489
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1490
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1491
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_previousMission_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_previousMission_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27981;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_previousMission_delta_old" ON "dbrdf_previousMission_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_previousMission_delta_old" ON "dbrdf_previousMission_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_previousMission_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/previousMission$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/previousMission$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_previousMission_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_previousMission_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27981 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/previousMission$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/previousMission$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_previousMission_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_previousMission_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27981 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27981, t0.o FROM "dbrdf_previousMission_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_previousMission_delta_old";
        INSERT INTO "dbrdf_previousMission_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_previousMission_delta_new" t0;
        TRUNCATE TABLE "dbrdf_previousMission_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1492
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1493
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1494
    ---- 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 "__triples" t0 WHERE t0.p = 27984;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27984 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27984 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27984, 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 1495
    ---- DEPENDS ON: 1494, 1338, 612, 113, 76, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/BaseballPlayer>(?X) :- <http://dbpedia.org/ontology/statisticValue>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27985 FROM "__triples" t0 WHERE t0.p = 27984 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27985);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/BaseballPlayer>(?X) :- <http://dbpedia.org/ontology/statisticLabel>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27985 FROM "__triples" t0 WHERE t0.p = 27828 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27985);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/BaseballPlayer>(?X) :- <http://dbpedia.org/ontology/statisticYear>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27985 FROM "__triples" t0 WHERE t0.p = 27094 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27985);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/BaseballPlayer>(?X) :- <http://dbpedia.org/ontology/battingSide>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27985 FROM "__triples" t0 WHERE t0.p = 26595 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27985);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/BaseballPlayer>(?X) :- <http://dbpedia.org/ontology/throwingSide>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27985 FROM "__triples" t0 WHERE t0.p = 26558 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27985);
    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_BaseballPlayer_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_BaseballPlayer_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27985;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_BaseballPlayer_delta_old" ON "dbrdf_BaseballPlayer_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_BaseballPlayer_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/BaseballPlayer$delta_new>(?Y) :- <http://dbpedia.org/ontology/BaseballPlayer$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_BaseballPlayer_delta_new"(s) SELECT t1.o FROM "dbrdf_BaseballPlayer_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 27985);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27985 FROM "dbrdf_BaseballPlayer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_BaseballPlayer_delta_old";
        INSERT INTO "dbrdf_BaseballPlayer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_BaseballPlayer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_BaseballPlayer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1496
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1497
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_isHandicappedAccessible_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_isHandicappedAccessible_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27987;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_isHandicappedAccessible_delta_old" ON "dbrdf_isHandicappedAccessible_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_isHandicappedAccessible_delta_old" ON "dbrdf_isHandicappedAccessible_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_isHandicappedAccessible_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/isHandicappedAccessible$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/isHandicappedAccessible$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_isHandicappedAccessible_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_isHandicappedAccessible_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27987 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/isHandicappedAccessible$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/isHandicappedAccessible$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_isHandicappedAccessible_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_isHandicappedAccessible_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27987 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27987, t0.o FROM "dbrdf_isHandicappedAccessible_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_isHandicappedAccessible_delta_old";
        INSERT INTO "dbrdf_isHandicappedAccessible_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_isHandicappedAccessible_delta_new" t0;
        TRUNCATE TABLE "dbrdf_isHandicappedAccessible_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1498
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ShoppingCenter_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ShoppingCenter_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27988;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ShoppingCenter_delta_old" ON "dbrdf_ShoppingCenter_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ShoppingCenter_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ShoppingMall_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ShoppingMall_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27989;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ShoppingMall_delta_old" ON "dbrdf_ShoppingMall_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ShoppingMall_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/ShoppingCenter$delta_new>(?X) :- <http://dbpedia.org/ontology/ShoppingMall$delta_old>(?X) .
        INSERT INTO "dbrdf_ShoppingCenter_delta_new"(s) SELECT t0.s FROM "dbrdf_ShoppingMall_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27988);


        -- <http://schema.org/ShoppingCenter$delta_new>(?Y) :- <http://schema.org/ShoppingCenter$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_ShoppingCenter_delta_new"(s) SELECT t1.o FROM "dbrdf_ShoppingCenter_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 27988);


        -- <http://dbpedia.org/ontology/ShoppingMall$delta_new>(?X) :- <http://schema.org/ShoppingCenter$delta_old>(?X) .
        INSERT INTO "dbrdf_ShoppingMall_delta_new"(s) SELECT t0.s FROM "dbrdf_ShoppingCenter_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27989);


        -- <http://dbpedia.org/ontology/ShoppingMall$delta_new>(?Y) :- <http://dbpedia.org/ontology/ShoppingMall$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_ShoppingMall_delta_new"(s) SELECT t1.o FROM "dbrdf_ShoppingMall_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 27989);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27988 FROM "dbrdf_ShoppingCenter_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_ShoppingCenter_delta_old";
        INSERT INTO "dbrdf_ShoppingCenter_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_ShoppingCenter_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ShoppingCenter_delta_new";

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27989 FROM "dbrdf_ShoppingMall_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_ShoppingMall_delta_old";
        INSERT INTO "dbrdf_ShoppingMall_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_ShoppingMall_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ShoppingMall_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1499
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1500
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_AutoRacingLeague_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_AutoRacingLeague_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27991;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_AutoRacingLeague_delta_old" ON "dbrdf_AutoRacingLeague_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_AutoRacingLeague_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27991 FROM "dbrdf_AutoRacingLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_AutoRacingLeague_delta_old";
        INSERT INTO "dbrdf_AutoRacingLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_AutoRacingLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_AutoRacingLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1501
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1502
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumTemperature_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_maximumTemperature_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27993;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_maximumTemperature_delta_old0" ON "dbrdf_maximumTemperature_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_maximumTemperature_delta_old0" ON "dbrdf_maximumTemperature_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumTemperature_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/Planet/maximumTemperature$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Planet/maximumTemperature$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_maximumTemperature_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_maximumTemperature_delta_old0" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27993 AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27993, t0.o FROM "dbrdf_maximumTemperature_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_maximumTemperature_delta_old0";
        INSERT INTO "dbrdf_maximumTemperature_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_maximumTemperature_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_maximumTemperature_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1503
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1504
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1505
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_CanadianFootballPlayer_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_CanadianFootballPlayer_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27996;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_CanadianFootballPlayer_delta_old" ON "dbrdf_CanadianFootballPlayer_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_CanadianFootballPlayer_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27996 FROM "dbrdf_CanadianFootballPlayer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_CanadianFootballPlayer_delta_old";
        INSERT INTO "dbrdf_CanadianFootballPlayer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_CanadianFootballPlayer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_CanadianFootballPlayer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1506
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27997, t0.o FROM "dbrdf_areaOfCatchment_delta_new0" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_areaOfCatchment_delta_old0";
        INSERT INTO "dbrdf_areaOfCatchment_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_areaOfCatchment_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_areaOfCatchment_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1507
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1508
    ---- DEPENDS ON: 1507, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_OfficeHolder_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_OfficeHolder_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27999;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_OfficeHolder_delta_old" ON "dbrdf_OfficeHolder_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_OfficeHolder_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27999 FROM "dbrdf_OfficeHolder_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_OfficeHolder_delta_old";
        INSERT INTO "dbrdf_OfficeHolder_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_OfficeHolder_delta_new" t0;
        TRUNCATE TABLE "dbrdf_OfficeHolder_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1509
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1510
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_PoloLeague_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_PoloLeague_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 28001;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_PoloLeague_delta_old" ON "dbrdf_PoloLeague_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_PoloLeague_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/PoloLeague$delta_new>(?Y) :- <http://dbpedia.org/ontology/PoloLeague$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_PoloLeague_delta_new"(s) SELECT t1.o FROM "dbrdf_PoloLeague_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 28001);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28001 FROM "dbrdf_PoloLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_PoloLeague_delta_old";
        INSERT INTO "dbrdf_PoloLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_PoloLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_PoloLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1511
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1512
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1513
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_virtualChannel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_virtualChannel_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28004;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_virtualChannel_delta_old" ON "dbrdf_virtualChannel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_virtualChannel_delta_old" ON "dbrdf_virtualChannel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_virtualChannel_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/virtualChannel$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/virtualChannel$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_virtualChannel_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_virtualChannel_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28004 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/virtualChannel$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/virtualChannel$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_virtualChannel_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_virtualChannel_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28004 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28004, t0.o FROM "dbrdf_virtualChannel_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_virtualChannel_delta_old";
        INSERT INTO "dbrdf_virtualChannel_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_virtualChannel_delta_new" t0;
        TRUNCATE TABLE "dbrdf_virtualChannel_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1514
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_wineYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_wineYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28005;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_wineYear_delta_old" ON "dbrdf_wineYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_wineYear_delta_old" ON "dbrdf_wineYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_wineYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/wineYear$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/wineYear$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_wineYear_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_wineYear_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28005 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/wineYear$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/wineYear$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_wineYear_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_wineYear_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28005 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28005, t0.o FROM "dbrdf_wineYear_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_wineYear_delta_old";
        INSERT INTO "dbrdf_wineYear_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_wineYear_delta_new" t0;
        TRUNCATE TABLE "dbrdf_wineYear_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1515
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1516
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_arm_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_arm_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28007;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_arm_delta_old" ON "dbrdf_arm_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_arm_delta_old" ON "dbrdf_arm_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_arm_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/arm$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/arm$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_arm_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_arm_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28007 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/arm$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/arm$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_arm_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_arm_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28007 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28007, t0.o FROM "dbrdf_arm_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_arm_delta_old";
        INSERT INTO "dbrdf_arm_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_arm_delta_new" t0;
        TRUNCATE TABLE "dbrdf_arm_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1517
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1518
    ---- 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 "__triples" t0 WHERE t0.p = 28009;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28009 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28009 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28009, 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 1519
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1520
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1521
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_seatingCapacity_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_seatingCapacity_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28012;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_seatingCapacity_delta_old" ON "dbrdf_seatingCapacity_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_seatingCapacity_delta_old" ON "dbrdf_seatingCapacity_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_seatingCapacity_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/seatingCapacity$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/seatingCapacity$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_seatingCapacity_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_seatingCapacity_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28012 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/seatingCapacity$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/seatingCapacity$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_seatingCapacity_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_seatingCapacity_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28012 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28012, t0.o FROM "dbrdf_seatingCapacity_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_seatingCapacity_delta_old";
        INSERT INTO "dbrdf_seatingCapacity_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_seatingCapacity_delta_new" t0;
        TRUNCATE TABLE "dbrdf_seatingCapacity_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1522
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_routeEndDirection_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_routeEndDirection_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28013;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_routeEndDirection_delta_old" ON "dbrdf_routeEndDirection_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_routeEndDirection_delta_old" ON "dbrdf_routeEndDirection_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_routeEndDirection_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/routeEndDirection$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/routeEndDirection$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_routeEndDirection_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_routeEndDirection_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28013 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/routeEndDirection$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/routeEndDirection$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_routeEndDirection_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_routeEndDirection_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28013 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28013, t0.o FROM "dbrdf_routeEndDirection_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_routeEndDirection_delta_old";
        INSERT INTO "dbrdf_routeEndDirection_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_routeEndDirection_delta_new" t0;
        TRUNCATE TABLE "dbrdf_routeEndDirection_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1523
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1524
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_distanceToCardiff_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_distanceToCardiff_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28015;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_distanceToCardiff_delta_old" ON "dbrdf_distanceToCardiff_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_distanceToCardiff_delta_old" ON "dbrdf_distanceToCardiff_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_distanceToCardiff_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/distanceToCardiff$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/distanceToCardiff$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_distanceToCardiff_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_distanceToCardiff_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28015 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/distanceToCardiff$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/distanceToCardiff$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_distanceToCardiff_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_distanceToCardiff_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28015 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28015, t0.o FROM "dbrdf_distanceToCardiff_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_distanceToCardiff_delta_old";
        INSERT INTO "dbrdf_distanceToCardiff_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_distanceToCardiff_delta_new" t0;
        TRUNCATE TABLE "dbrdf_distanceToCardiff_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1525
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1526
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_year_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_year_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28017;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_year_delta_old" ON "dbrdf_year_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_year_delta_old" ON "dbrdf_year_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_year_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28017, t0.o FROM "dbrdf_year_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_year_delta_old";
        INSERT INTO "dbrdf_year_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_year_delta_new" t0;
        TRUNCATE TABLE "dbrdf_year_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1527
    ---- DEPENDS ON: 1526, 1452, 1310, 631, 436, 137, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Sales>(?X) :- <http://dbpedia.org/ontology/startYearOfSales>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28018 FROM "__triples" t0 WHERE t0.p = 27942 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28018);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/Sales>(?X) :- <http://dbpedia.org/ontology/year>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28018 FROM "__triples" t0 WHERE t0.p = 28017 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28018);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/Sales>(?X1) :- <http://dbpedia.org/ontology/sales>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.o, 2, 28018 FROM "__triples" t0 WHERE t0.p = 26918 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.o AND ex.p = 2 AND ex.o = 28018);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/Sales>(?X) :- <http://dbpedia.org/ontology/model>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28018 FROM "__triples" t0 WHERE t0.p = 27113 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28018);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/Sales>(?X) :- <http://dbpedia.org/ontology/usSales>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28018 FROM "__triples" t0 WHERE t0.p = 27800 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28018);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/Sales>(?X) :- <http://dbpedia.org/ontology/endYearOfSales>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28018 FROM "__triples" t0 WHERE t0.p = 26619 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28018);
    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_Sales_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Sales_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 28018;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Sales_delta_old" ON "dbrdf_Sales_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Sales_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/Sales$delta_new>(?Y) :- <http://dbpedia.org/ontology/Sales$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Sales_delta_new"(s) SELECT t1.o FROM "dbrdf_Sales_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 28018);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28018 FROM "dbrdf_Sales_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Sales_delta_old";
        INSERT INTO "dbrdf_Sales_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Sales_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Sales_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1528
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1529
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1530
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1531
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1532
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1533
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1534
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerBandMember_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_formerBandMember_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28025;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_formerBandMember_delta_old" ON "dbrdf_formerBandMember_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_formerBandMember_delta_old" ON "dbrdf_formerBandMember_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerBandMember_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/formerBandMember$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/formerBandMember$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_formerBandMember_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_formerBandMember_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28025 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/formerBandMember$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/formerBandMember$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_formerBandMember_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_formerBandMember_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28025 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28025, t0.o FROM "dbrdf_formerBandMember_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_formerBandMember_delta_old";
        INSERT INTO "dbrdf_formerBandMember_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_formerBandMember_delta_new" t0;
        TRUNCATE TABLE "dbrdf_formerBandMember_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1535
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1536
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1537
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1538
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1539
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1540
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1541
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_managerYears_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_managerYears_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28032;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_managerYears_delta_old" ON "dbrdf_managerYears_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_managerYears_delta_old" ON "dbrdf_managerYears_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_managerYears_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/managerYears$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/managerYears$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_managerYears_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_managerYears_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28032 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/managerYears$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/managerYears$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_managerYears_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_managerYears_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28032 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28032, t0.o FROM "dbrdf_managerYears_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_managerYears_delta_old";
        INSERT INTO "dbrdf_managerYears_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_managerYears_delta_new" t0;
        TRUNCATE TABLE "dbrdf_managerYears_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1542
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1543
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1544
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_MixedMartialArtsLeague_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_MixedMartialArtsLeague_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 28035;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_MixedMartialArtsLeague_delta_old" ON "dbrdf_MixedMartialArtsLeague_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_MixedMartialArtsLeague_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/MixedMartialArtsLeague$delta_new>(?Y) :- <http://dbpedia.org/ontology/MixedMartialArtsLeague$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_MixedMartialArtsLeague_delta_new"(s) SELECT t1.o FROM "dbrdf_MixedMartialArtsLeague_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 28035);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28035 FROM "dbrdf_MixedMartialArtsLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_MixedMartialArtsLeague_delta_old";
        INSERT INTO "dbrdf_MixedMartialArtsLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_MixedMartialArtsLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_MixedMartialArtsLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1545
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1546
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cmpEvaDuration_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cmpEvaDuration_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28037;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cmpEvaDuration_delta_old0" ON "dbrdf_cmpEvaDuration_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_cmpEvaDuration_delta_old0" ON "dbrdf_cmpEvaDuration_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cmpEvaDuration_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28037, t0.o FROM "dbrdf_cmpEvaDuration_delta_new0" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_cmpEvaDuration_delta_old0";
        INSERT INTO "dbrdf_cmpEvaDuration_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cmpEvaDuration_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_cmpEvaDuration_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1547
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1548
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1549
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1550
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1551
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1552
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1553
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1554
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1555
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1556
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_staff_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_staff_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28047;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_staff_delta_old" ON "dbrdf_staff_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_staff_delta_old" ON "dbrdf_staff_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_staff_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/staff$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/staff$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_staff_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_staff_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28047 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/staff$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/staff$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_staff_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_staff_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28047 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28047, t0.o FROM "dbrdf_staff_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_staff_delta_old";
        INSERT INTO "dbrdf_staff_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_staff_delta_new" t0;
        TRUNCATE TABLE "dbrdf_staff_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1557
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumTemperature_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_maximumTemperature_delta_old1"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28048;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_maximumTemperature_delta_old1" ON "dbrdf_maximumTemperature_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_maximumTemperature_delta_old1" ON "dbrdf_maximumTemperature_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumTemperature_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/maximumTemperature$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/maximumTemperature$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_maximumTemperature_delta_new1"(s, o) SELECT t1.o, t0.o FROM "dbrdf_maximumTemperature_delta_old1" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28048 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/maximumTemperature$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/maximumTemperature$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_maximumTemperature_delta_new1"(s, o) SELECT t0.s, t1.o FROM "dbrdf_maximumTemperature_delta_old1" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28048 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28048, t0.o FROM "dbrdf_maximumTemperature_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_maximumTemperature_delta_old1";
        INSERT INTO "dbrdf_maximumTemperature_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_maximumTemperature_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_maximumTemperature_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1558
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_modelEndYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_modelEndYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28049;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_modelEndYear_delta_old" ON "dbrdf_modelEndYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_modelEndYear_delta_old" ON "dbrdf_modelEndYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_modelEndYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/modelEndYear$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/modelEndYear$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_modelEndYear_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_modelEndYear_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28049 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/modelEndYear$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/modelEndYear$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_modelEndYear_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_modelEndYear_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28049 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28049, t0.o FROM "dbrdf_modelEndYear_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_modelEndYear_delta_old";
        INSERT INTO "dbrdf_modelEndYear_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_modelEndYear_delta_new" t0;
        TRUNCATE TABLE "dbrdf_modelEndYear_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1559
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_eloRecord_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_eloRecord_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28050;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_eloRecord_delta_old" ON "dbrdf_eloRecord_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_eloRecord_delta_old" ON "dbrdf_eloRecord_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_eloRecord_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/eloRecord$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/eloRecord$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_eloRecord_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_eloRecord_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28050 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/eloRecord$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/eloRecord$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_eloRecord_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_eloRecord_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28050 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28050, t0.o FROM "dbrdf_eloRecord_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_eloRecord_delta_old";
        INSERT INTO "dbrdf_eloRecord_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_eloRecord_delta_new" t0;
        TRUNCATE TABLE "dbrdf_eloRecord_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1560
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_previousEditor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_previousEditor_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28051;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_previousEditor_delta_old" ON "dbrdf_previousEditor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_previousEditor_delta_old" ON "dbrdf_previousEditor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_previousEditor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/previousEditor$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/previousEditor$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_previousEditor_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_previousEditor_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28051 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/previousEditor$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/previousEditor$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_previousEditor_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_previousEditor_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28051 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28051, t0.o FROM "dbrdf_previousEditor_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_previousEditor_delta_old";
        INSERT INTO "dbrdf_previousEditor_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_previousEditor_delta_new" t0;
        TRUNCATE TABLE "dbrdf_previousEditor_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1561
    ---- DEPENDS ON: 1560, 1056, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Magazine>(?X) :- <http://dbpedia.org/ontology/previousEditor>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28052 FROM "__triples" t0 WHERE t0.p = 28051 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28052);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/Magazine>(?X) :- <http://dbpedia.org/ontology/editorTitle>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28052 FROM "__triples" t0 WHERE t0.p = 27541 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28052);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Magazine_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Magazine_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 28052;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Magazine_delta_old" ON "dbrdf_Magazine_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Magazine_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Magazine$delta_new>(?Y) :- <http://dbpedia.org/ontology/Magazine$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Magazine_delta_new"(s) SELECT t1.o FROM "dbrdf_Magazine_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 28052);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28052 FROM "dbrdf_Magazine_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Magazine_delta_old";
        INSERT INTO "dbrdf_Magazine_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Magazine_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Magazine_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1562
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_crewMember_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_crewMember_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28053;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_crewMember_delta_old" ON "dbrdf_crewMember_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_crewMember_delta_old" ON "dbrdf_crewMember_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_crewMember_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/crewMember$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/crewMember$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_crewMember_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_crewMember_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28053 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/crewMember$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/crewMember$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_crewMember_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_crewMember_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28053 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28053, t0.o FROM "dbrdf_crewMember_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_crewMember_delta_old";
        INSERT INTO "dbrdf_crewMember_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_crewMember_delta_new" t0;
        TRUNCATE TABLE "dbrdf_crewMember_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1563
    ---- DEPENDS ON: 1562, 1351, 802, 318, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Astronaut>(?X) :- <http://dbpedia.org/ontology/selection>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28054 FROM "__triples" t0 WHERE t0.p = 27285 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28054);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

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

    -- [Rule] <http://dbpedia.org/ontology/Astronaut>(?X) :- <http://dbpedia.org/ontology/Astronaut/timeInSpace>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28054 FROM "__triples" t0 WHERE t0.p = 26800 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28054);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/Astronaut>(?X1) :- <http://dbpedia.org/ontology/crewMember>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.o, 2, 28054 FROM "__triples" t0 WHERE t0.p = 28053 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.o AND ex.p = 2 AND ex.o = 28054);
    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_Astronaut_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Astronaut_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 28054;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Astronaut_delta_old" ON "dbrdf_Astronaut_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Astronaut_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/Astronaut$delta_new>(?Y) :- <http://dbpedia.org/ontology/Astronaut$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Astronaut_delta_new"(s) SELECT t1.o FROM "dbrdf_Astronaut_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 28054);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28054 FROM "dbrdf_Astronaut_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Astronaut_delta_old";
        INSERT INTO "dbrdf_Astronaut_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Astronaut_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Astronaut_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1564
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_elo_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_elo_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28055;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_elo_delta_old" ON "dbrdf_elo_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_elo_delta_old" ON "dbrdf_elo_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_elo_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/elo$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/elo$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_elo_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_elo_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28055 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/elo$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/elo$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_elo_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_elo_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28055 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28055, t0.o FROM "dbrdf_elo_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_elo_delta_old";
        INSERT INTO "dbrdf_elo_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_elo_delta_new" t0;
        TRUNCATE TABLE "dbrdf_elo_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1565
    ---- DEPENDS ON: 1564, 1559, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/ChessPlayer>(?X) :- <http://dbpedia.org/ontology/elo>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28056 FROM "__triples" t0 WHERE t0.p = 28055 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28056);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/ChessPlayer>(?X) :- <http://dbpedia.org/ontology/eloRecord>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28056 FROM "__triples" t0 WHERE t0.p = 28050 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28056);
    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_ChessPlayer_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ChessPlayer_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 28056;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ChessPlayer_delta_old" ON "dbrdf_ChessPlayer_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ChessPlayer_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/ChessPlayer$delta_new>(?Y) :- <http://dbpedia.org/ontology/ChessPlayer$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_ChessPlayer_delta_new"(s) SELECT t1.o FROM "dbrdf_ChessPlayer_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 28056);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28056 FROM "dbrdf_ChessPlayer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_ChessPlayer_delta_old";
        INSERT INTO "dbrdf_ChessPlayer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_ChessPlayer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ChessPlayer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1566
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_soccerTournamentTopScorer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_soccerTournamentTopScorer_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28057;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_soccerTournamentTopScorer_delta_old" ON "dbrdf_soccerTournamentTopScorer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_soccerTournamentTopScorer_delta_old" ON "dbrdf_soccerTournamentTopScorer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_soccerTournamentTopScorer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/soccerTournamentTopScorer$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/soccerTournamentTopScorer$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_soccerTournamentTopScorer_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_soccerTournamentTopScorer_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28057 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/soccerTournamentTopScorer$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/soccerTournamentTopScorer$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_soccerTournamentTopScorer_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_soccerTournamentTopScorer_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28057 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28057, t0.o FROM "dbrdf_soccerTournamentTopScorer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_soccerTournamentTopScorer_delta_old";
        INSERT INTO "dbrdf_soccerTournamentTopScorer_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_soccerTournamentTopScorer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_soccerTournamentTopScorer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1567
    ---- DEPENDS ON: 1566, 1406, 1384, 1309, 1005, 197, 163, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/SoccerTournament>(?X) :- <http://dbpedia.org/ontology/soccerTournamentTopScorer>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28058 FROM "__triples" t0 WHERE t0.p = 28057 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28058);
    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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28058 FROM "__triples" t0 WHERE t0.p = 27874 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28058);
    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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28058 FROM "__triples" t0 WHERE t0.p = 27799 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28058);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/SoccerTournament>(?X) :- <http://dbpedia.org/ontology/soccerTournamentLastChampion>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28058 FROM "__triples" t0 WHERE t0.p = 27896 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28058);
    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 "__triples"(s, p, o) SELECT DISTINCT t0.o, 2, 28058 FROM "__triples" t0 WHERE t0.p = 27799 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.o AND ex.p = 2 AND ex.o = 28058);
    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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28058 FROM "__triples" t0 WHERE t0.p = 26679 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28058);
    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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28058 FROM "__triples" t0 WHERE t0.p = 27490 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28058);
    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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28058 FROM "__triples" t0 WHERE t0.p = 26645 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28058);
    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 "__triples"(s, p, o) SELECT DISTINCT t0.o, 2, 28058 FROM "__triples" t0 WHERE t0.p = 26645 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.o AND ex.p = 2 AND ex.o = 28058);
    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 "__triples"(s, p, o) SELECT DISTINCT t0.o, 2, 28058 FROM "__triples" t0 WHERE t0.p = 27874 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.o AND ex.p = 2 AND ex.o = 28058);
    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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 28058;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 28058);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28058 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 1568
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_barPassRate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_barPassRate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28059;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_barPassRate_delta_old" ON "dbrdf_barPassRate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_barPassRate_delta_old" ON "dbrdf_barPassRate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_barPassRate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/barPassRate$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/barPassRate$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_barPassRate_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_barPassRate_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28059 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/barPassRate$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/barPassRate$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_barPassRate_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_barPassRate_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28059 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28059, t0.o FROM "dbrdf_barPassRate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_barPassRate_delta_old";
        INSERT INTO "dbrdf_barPassRate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_barPassRate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_barPassRate_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1569
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_operator_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_operator_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28060;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_operator_delta_old" ON "dbrdf_operator_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_operator_delta_old" ON "dbrdf_operator_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_operator_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/operator$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/operator$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_operator_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_operator_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28060 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/operator$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/operator$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_operator_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_operator_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28060 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28060, t0.o FROM "dbrdf_operator_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_operator_delta_old";
        INSERT INTO "dbrdf_operator_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_operator_delta_new" t0;
        TRUNCATE TABLE "dbrdf_operator_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1570
    ---- DEPENDS ON: 108, 100, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Song>(?X) :- <http://dbpedia.org/ontology/EurovisionSongContestEntry>(?X) .
    INSERT INTO "__triples"(s, p, o) SELECT t0.s, 2, 28061 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26590 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28061);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/Song>(?X) :- <http://dbpedia.org/ontology/trackNumber>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28061 FROM "__triples" t0 WHERE t0.p = 26582 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28061);
    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_Song_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Song_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 28061;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Song_delta_old" ON "dbrdf_Song_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Song_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_MusicRecording_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_MusicRecording_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 28062;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_MusicRecording_delta_old" ON "dbrdf_MusicRecording_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_MusicRecording_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/Song$delta_new>(?X) :- <http://schema.org/MusicRecording$delta_old>(?X) .
        INSERT INTO "dbrdf_Song_delta_new"(s) SELECT t0.s FROM "dbrdf_MusicRecording_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28061);


        -- <http://dbpedia.org/ontology/Song$delta_new>(?Y) :- <http://dbpedia.org/ontology/Song$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Song_delta_new"(s) SELECT t1.o FROM "dbrdf_Song_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 28061);


        -- <http://schema.org/MusicRecording$delta_new>(?X) :- <http://dbpedia.org/ontology/Song$delta_old>(?X) .
        INSERT INTO "dbrdf_MusicRecording_delta_new"(s) SELECT t0.s FROM "dbrdf_Song_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28062);


        -- <http://schema.org/MusicRecording$delta_new>(?Y) :- <http://schema.org/MusicRecording$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_MusicRecording_delta_new"(s) SELECT t1.o FROM "dbrdf_MusicRecording_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 28062);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28061 FROM "dbrdf_Song_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Song_delta_old";
        INSERT INTO "dbrdf_Song_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Song_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Song_delta_new";

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28062 FROM "dbrdf_MusicRecording_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_MusicRecording_delta_old";
        INSERT INTO "dbrdf_MusicRecording_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_MusicRecording_delta_new" t0;
        TRUNCATE TABLE "dbrdf_MusicRecording_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1571
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nationalTeam_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nationalTeam_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28063;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nationalTeam_delta_old" ON "dbrdf_nationalTeam_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nationalTeam_delta_old" ON "dbrdf_nationalTeam_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nationalTeam_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/nationalTeam$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/nationalTeam$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_nationalTeam_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_nationalTeam_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28063 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/nationalTeam$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/nationalTeam$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_nationalTeam_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_nationalTeam_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28063 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28063, t0.o FROM "dbrdf_nationalTeam_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_nationalTeam_delta_old";
        INSERT INTO "dbrdf_nationalTeam_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_nationalTeam_delta_new" t0;
        TRUNCATE TABLE "dbrdf_nationalTeam_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1572
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_fansgroup_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_fansgroup_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28064;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_fansgroup_delta_old" ON "dbrdf_fansgroup_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_fansgroup_delta_old" ON "dbrdf_fansgroup_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_fansgroup_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/fansgroup$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/fansgroup$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_fansgroup_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_fansgroup_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28064 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/fansgroup$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/fansgroup$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_fansgroup_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_fansgroup_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28064 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28064, t0.o FROM "dbrdf_fansgroup_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_fansgroup_delta_old";
        INSERT INTO "dbrdf_fansgroup_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_fansgroup_delta_new" t0;
        TRUNCATE TABLE "dbrdf_fansgroup_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1573
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_wins_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_wins_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28065;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_wins_delta_old" ON "dbrdf_wins_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_wins_delta_old" ON "dbrdf_wins_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_wins_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/wins$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/wins$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_wins_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_wins_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28065 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/wins$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/wins$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_wins_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_wins_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28065 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28065, t0.o FROM "dbrdf_wins_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_wins_delta_old";
        INSERT INTO "dbrdf_wins_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_wins_delta_new" t0;
        TRUNCATE TABLE "dbrdf_wins_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1574
    ---- DEPENDS ON: 1573, 1488, 1434, 1114, 1000, 926, 909, 733, 567, 435, 396, 319, 312, 301, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/FormulaOneRacer>(?X) :- <http://dbpedia.org/ontology/wins>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28066 FROM "__triples" t0 WHERE t0.p = 28065 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28066);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

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

    -- [Rule] <http://dbpedia.org/ontology/FormulaOneRacer>(?X) :- <http://dbpedia.org/ontology/podiums>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28066 FROM "__triples" t0 WHERE t0.p = 27600 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28066);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/FormulaOneRacer>(?X) :- <http://dbpedia.org/ontology/poles>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28066 FROM "__triples" t0 WHERE t0.p = 27410 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28066);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/FormulaOneRacer>(?X) :- <http://dbpedia.org/ontology/races>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28066 FROM "__triples" t0 WHERE t0.p = 27216 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28066);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/FormulaOneRacer>(?X) :- <http://dbpedia.org/ontology/lastSeason>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28066 FROM "__triples" t0 WHERE t0.p = 27485 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28066);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

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

    -- [Rule] <http://dbpedia.org/ontology/FormulaOneRacer>(?X) :- <http://dbpedia.org/ontology/lastPosition>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28066 FROM "__triples" t0 WHERE t0.p = 26878 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28066);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/FormulaOneRacer>(?X) :- <http://dbpedia.org/ontology/fastestLap>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28066 FROM "__triples" t0 WHERE t0.p = 26917 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28066);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/FormulaOneRacer>(?X) :- <http://dbpedia.org/ontology/carNumber>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28066 FROM "__triples" t0 WHERE t0.p = 26794 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28066);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/FormulaOneRacer>(?X) :- <http://dbpedia.org/ontology/championships>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28066 FROM "__triples" t0 WHERE t0.p = 26801 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28066);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

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

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

    -- [Rule] <http://dbpedia.org/ontology/FormulaOneRacer>(?X) :- <http://dbpedia.org/ontology/careerPoints>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28066 FROM "__triples" t0 WHERE t0.p = 26783 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28066);
    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_FormulaOneRacer_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_FormulaOneRacer_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 28066;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_FormulaOneRacer_delta_old" ON "dbrdf_FormulaOneRacer_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_FormulaOneRacer_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/FormulaOneRacer$delta_new>(?Y) :- <http://dbpedia.org/ontology/FormulaOneRacer$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_FormulaOneRacer_delta_new"(s) SELECT t1.o FROM "dbrdf_FormulaOneRacer_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 28066);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28066 FROM "dbrdf_FormulaOneRacer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_FormulaOneRacer_delta_old";
        INSERT INTO "dbrdf_FormulaOneRacer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_FormulaOneRacer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_FormulaOneRacer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1575
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_subsequentWork_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_subsequentWork_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28067;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_subsequentWork_delta_old" ON "dbrdf_subsequentWork_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_subsequentWork_delta_old" ON "dbrdf_subsequentWork_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_subsequentWork_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/subsequentWork$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/subsequentWork$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_subsequentWork_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_subsequentWork_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28067 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/subsequentWork$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/subsequentWork$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_subsequentWork_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_subsequentWork_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28067 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28067, t0.o FROM "dbrdf_subsequentWork_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_subsequentWork_delta_old";
        INSERT INTO "dbrdf_subsequentWork_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_subsequentWork_delta_new" t0;
        TRUNCATE TABLE "dbrdf_subsequentWork_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1576
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_orderInOffice_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_orderInOffice_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28068;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_orderInOffice_delta_old" ON "dbrdf_orderInOffice_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_orderInOffice_delta_old" ON "dbrdf_orderInOffice_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_orderInOffice_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/orderInOffice$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/orderInOffice$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_orderInOffice_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_orderInOffice_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28068 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/orderInOffice$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/orderInOffice$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_orderInOffice_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_orderInOffice_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28068 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28068, t0.o FROM "dbrdf_orderInOffice_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_orderInOffice_delta_old";
        INSERT INTO "dbrdf_orderInOffice_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_orderInOffice_delta_new" t0;
        TRUNCATE TABLE "dbrdf_orderInOffice_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1577
    ---- DEPENDS ON: 760, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/NationalCollegiateAthleticAssociationAthlete>(?X) :- <http://dbpedia.org/ontology/formerHighschool>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28069 FROM "__triples" t0 WHERE t0.p = 27243 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28069);
    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_NationalCollegiateAthleticAssociationAthlete_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_NationalCollegiateAthleticAssociationAthlete_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 28069;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_NationalCollegiateAthleticAssociationAthlete_delta_old" ON "dbrdf_NationalCollegiateAthleticAssociationAthlete_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_NationalCollegiateAthleticAssociationAthlete_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/NationalCollegiateAthleticAssociationAthlete$delta_new>(?Y) :- <http://dbpedia.org/ontology/NationalCollegiateAthleticAssociationAthlete$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_NationalCollegiateAthleticAssociationAthlete_delta_new"(s) SELECT t1.o FROM "dbrdf_NationalCollegiateAthleticAssociationAthlete_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 28069);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28069 FROM "dbrdf_NationalCollegiateAthleticAssociationAthlete_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_NationalCollegiateAthleticAssociationAthlete_delta_old";
        INSERT INTO "dbrdf_NationalCollegiateAthleticAssociationAthlete_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_NationalCollegiateAthleticAssociationAthlete_delta_new" t0;
        TRUNCATE TABLE "dbrdf_NationalCollegiateAthleticAssociationAthlete_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1578
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_finalFlight_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_finalFlight_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28070;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_finalFlight_delta_old" ON "dbrdf_finalFlight_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_finalFlight_delta_old" ON "dbrdf_finalFlight_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_finalFlight_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/finalFlight$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/finalFlight$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_finalFlight_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_finalFlight_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28070 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/finalFlight$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/finalFlight$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_finalFlight_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_finalFlight_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28070 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28070, t0.o FROM "dbrdf_finalFlight_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_finalFlight_delta_old";
        INSERT INTO "dbrdf_finalFlight_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_finalFlight_delta_new" t0;
        TRUNCATE TABLE "dbrdf_finalFlight_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1579
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfEntrances_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfEntrances_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28071;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfEntrances_delta_old" ON "dbrdf_numberOfEntrances_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfEntrances_delta_old" ON "dbrdf_numberOfEntrances_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfEntrances_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/numberOfEntrances$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/numberOfEntrances$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_numberOfEntrances_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_numberOfEntrances_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28071 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/numberOfEntrances$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/numberOfEntrances$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_numberOfEntrances_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_numberOfEntrances_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28071 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28071, t0.o FROM "dbrdf_numberOfEntrances_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_numberOfEntrances_delta_old";
        INSERT INTO "dbrdf_numberOfEntrances_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfEntrances_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfEntrances_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1580
    ---- DEPENDS ON: 1579, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Cave>(?X) :- <http://dbpedia.org/ontology/numberOfEntrances>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28072 FROM "__triples" t0 WHERE t0.p = 28071 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28072);
    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_Cave_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Cave_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 28072;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Cave_delta_old" ON "dbrdf_Cave_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Cave_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/Cave$delta_new>(?Y) :- <http://dbpedia.org/ontology/Cave$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Cave_delta_new"(s) SELECT t1.o FROM "dbrdf_Cave_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 28072);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28072 FROM "dbrdf_Cave_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Cave_delta_old";
        INSERT INTO "dbrdf_Cave_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Cave_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Cave_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1581
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_facilityId_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_facilityId_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28073;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_facilityId_delta_old" ON "dbrdf_facilityId_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_facilityId_delta_old" ON "dbrdf_facilityId_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_facilityId_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/facilityId$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/facilityId$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_facilityId_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_facilityId_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28073 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/facilityId$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/facilityId$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_facilityId_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_facilityId_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28073 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28073, t0.o FROM "dbrdf_facilityId_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_facilityId_delta_old";
        INSERT INTO "dbrdf_facilityId_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_facilityId_delta_new" t0;
        TRUNCATE TABLE "dbrdf_facilityId_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1582
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_airportUsing_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_airportUsing_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28074;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_airportUsing_delta_old" ON "dbrdf_airportUsing_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_airportUsing_delta_old" ON "dbrdf_airportUsing_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_airportUsing_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/airportUsing$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/airportUsing$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_airportUsing_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_airportUsing_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28074 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/airportUsing$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/airportUsing$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_airportUsing_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_airportUsing_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28074 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28074, t0.o FROM "dbrdf_airportUsing_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_airportUsing_delta_old";
        INSERT INTO "dbrdf_airportUsing_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_airportUsing_delta_new" t0;
        TRUNCATE TABLE "dbrdf_airportUsing_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1583
    ---- DEPENDS ON: 1582, 1327, 1256, 999, 928, 712, 453, 326, 173, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Airport>(?X) :- <http://dbpedia.org/ontology/runwayDesignation>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28076 FROM "__triples" t0 WHERE t0.p = 27484 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28076);
    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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28076 FROM "__triples" t0 WHERE t0.p = 27412 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28076);
    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 "__triples"(s, p, o) SELECT DISTINCT t0.o, 2, 28076 FROM "__triples" t0 WHERE t0.p = 27195 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.o AND ex.p = 2 AND ex.o = 28076);
    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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28076 FROM "__triples" t0 WHERE t0.p = 27743 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28076);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/Airport>(?X1) :- <http://dbpedia.org/ontology/hubAirport>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.o, 2, 28076 FROM "__triples" t0 WHERE t0.p = 26935 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.o AND ex.p = 2 AND ex.o = 28076);
    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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28076 FROM "__triples" t0 WHERE t0.p = 28074 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28076);
    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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28076 FROM "__triples" t0 WHERE t0.p = 26808 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28076);
    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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28076 FROM "__triples" t0 WHERE t0.p = 26655 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28076);
    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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28076 FROM "__triples" t0 WHERE t0.p = 27817 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28076);
    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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 28075;
    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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 28076;
    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 "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28075);


        -- <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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 28075);


        -- <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 "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28076);


        -- <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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 28076);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28075 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28076 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 1584
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_depth_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_depth_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28077;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_depth_delta_old" ON "dbrdf_depth_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_depth_delta_old" ON "dbrdf_depth_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_depth_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/depth$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/depth$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_depth_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_depth_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28077 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/depth$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/depth$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_depth_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_depth_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28077 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28077, t0.o FROM "dbrdf_depth_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_depth_delta_old";
        INSERT INTO "dbrdf_depth_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_depth_delta_new" t0;
        TRUNCATE TABLE "dbrdf_depth_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1585
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_runtime_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_runtime_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28078;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_runtime_delta_old0" ON "dbrdf_runtime_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_runtime_delta_old0" ON "dbrdf_runtime_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_runtime_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/runtime$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/runtime$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_runtime_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_runtime_delta_old0" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28078 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/runtime$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/runtime$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_runtime_delta_new0"(s, o) SELECT t0.s, t1.o FROM "dbrdf_runtime_delta_old0" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28078 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28078, t0.o FROM "dbrdf_runtime_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_runtime_delta_old0";
        INSERT INTO "dbrdf_runtime_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_runtime_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_runtime_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1586
    ---- DEPENDS ON: 1394, 1218, 941, 557, 339, 43, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Album>(?X) :- <http://dbpedia.org/ontology/totalDiscs>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28079 FROM "__triples" t0 WHERE t0.p = 27704 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28079);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/Album>(?X) :- <http://dbpedia.org/ontology/longtype>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28079 FROM "__triples" t0 WHERE t0.p = 27426 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28079);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/Album>(?X) :- <http://dbpedia.org/ontology/totalTracks>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28079 FROM "__triples" t0 WHERE t0.p = 27884 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28079);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/Album>(?X) :- <http://dbpedia.org/ontology/review>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28079 FROM "__triples" t0 WHERE t0.p = 26821 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28079);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/Album>(?X) :- <http://dbpedia.org/ontology/compiler>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28079 FROM "__triples" t0 WHERE t0.p = 27039 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28079);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/Album>(?X1) :- <http://dbpedia.org/ontology/album>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.o, 2, 28079 FROM "__triples" t0 WHERE t0.p = 26525 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.o AND ex.p = 2 AND ex.o = 28079);
    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_Album_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Album_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 28079;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Album_delta_old" ON "dbrdf_Album_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Album_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_MusicAlbum_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_MusicAlbum_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 28080;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_MusicAlbum_delta_old" ON "dbrdf_MusicAlbum_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_MusicAlbum_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/Album$delta_new>(?X) :- <http://schema.org/MusicAlbum$delta_old>(?X) .
        INSERT INTO "dbrdf_Album_delta_new"(s) SELECT t0.s FROM "dbrdf_MusicAlbum_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28079);


        -- <http://dbpedia.org/ontology/Album$delta_new>(?Y) :- <http://dbpedia.org/ontology/Album$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Album_delta_new"(s) SELECT t1.o FROM "dbrdf_Album_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 28079);


        -- <http://schema.org/MusicAlbum$delta_new>(?X) :- <http://dbpedia.org/ontology/Album$delta_old>(?X) .
        INSERT INTO "dbrdf_MusicAlbum_delta_new"(s) SELECT t0.s FROM "dbrdf_Album_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28080);


        -- <http://schema.org/MusicAlbum$delta_new>(?Y) :- <http://schema.org/MusicAlbum$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_MusicAlbum_delta_new"(s) SELECT t1.o FROM "dbrdf_MusicAlbum_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 28080);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28079 FROM "dbrdf_Album_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Album_delta_old";
        INSERT INTO "dbrdf_Album_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Album_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Album_delta_new";

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28080 FROM "dbrdf_MusicAlbum_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_MusicAlbum_delta_old";
        INSERT INTO "dbrdf_MusicAlbum_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_MusicAlbum_delta_new" t0;
        TRUNCATE TABLE "dbrdf_MusicAlbum_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1587
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_governorGeneral_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_governorGeneral_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28081;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_governorGeneral_delta_old" ON "dbrdf_governorGeneral_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_governorGeneral_delta_old" ON "dbrdf_governorGeneral_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_governorGeneral_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/governorGeneral$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/governorGeneral$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_governorGeneral_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_governorGeneral_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28081 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/governorGeneral$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/governorGeneral$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_governorGeneral_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_governorGeneral_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28081 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28081, t0.o FROM "dbrdf_governorGeneral_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_governorGeneral_delta_old";
        INSERT INTO "dbrdf_governorGeneral_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_governorGeneral_delta_new" t0;
        TRUNCATE TABLE "dbrdf_governorGeneral_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1588
    ---- DEPENDS ON: 502, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/SportsTeamSeason>(?X) :- <http://dbpedia.org/ontology/SoccerClubSeason>(?X) .
    INSERT INTO "__triples"(s, p, o) SELECT t0.s, 2, 28082 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26984 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28082);
    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_SportsTeamSeason_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SportsTeamSeason_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 28082;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SportsTeamSeason_delta_old" ON "dbrdf_SportsTeamSeason_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SportsTeamSeason_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/SportsTeamSeason$delta_new>(?Y) :- <http://dbpedia.org/ontology/SportsTeamSeason$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_SportsTeamSeason_delta_new"(s) SELECT t1.o FROM "dbrdf_SportsTeamSeason_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 28082);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28082 FROM "dbrdf_SportsTeamSeason_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SportsTeamSeason_delta_old";
        INSERT INTO "dbrdf_SportsTeamSeason_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SportsTeamSeason_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SportsTeamSeason_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1589
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_teamName_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_teamName_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28083;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_teamName_delta_old" ON "dbrdf_teamName_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_teamName_delta_old" ON "dbrdf_teamName_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_teamName_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/teamName$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/teamName$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_teamName_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_teamName_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28083 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/teamName$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/teamName$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_teamName_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_teamName_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28083 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28083, t0.o FROM "dbrdf_teamName_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_teamName_delta_old";
        INSERT INTO "dbrdf_teamName_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_teamName_delta_new" t0;
        TRUNCATE TABLE "dbrdf_teamName_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1590
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_spacecraft_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_spacecraft_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28084;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_spacecraft_delta_old" ON "dbrdf_spacecraft_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_spacecraft_delta_old" ON "dbrdf_spacecraft_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_spacecraft_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/spacecraft$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/spacecraft$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_spacecraft_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_spacecraft_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28084 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/spacecraft$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/spacecraft$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_spacecraft_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_spacecraft_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28084 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28084, t0.o FROM "dbrdf_spacecraft_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_spacecraft_delta_old";
        INSERT INTO "dbrdf_spacecraft_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_spacecraft_delta_new" t0;
        TRUNCATE TABLE "dbrdf_spacecraft_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1591
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_averageClassSize_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_averageClassSize_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28085;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_averageClassSize_delta_old" ON "dbrdf_averageClassSize_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_averageClassSize_delta_old" ON "dbrdf_averageClassSize_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_averageClassSize_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/averageClassSize$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/averageClassSize$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_averageClassSize_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_averageClassSize_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28085 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/averageClassSize$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/averageClassSize$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_averageClassSize_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_averageClassSize_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28085 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28085, t0.o FROM "dbrdf_averageClassSize_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_averageClassSize_delta_old";
        INSERT INTO "dbrdf_averageClassSize_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_averageClassSize_delta_new" t0;
        TRUNCATE TABLE "dbrdf_averageClassSize_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1592
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_reopened_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_reopened_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28086;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_reopened_delta_old" ON "dbrdf_reopened_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_reopened_delta_old" ON "dbrdf_reopened_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_reopened_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/reopened$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/reopened$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_reopened_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_reopened_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28086 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/reopened$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/reopened$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_reopened_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_reopened_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28086 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28086, t0.o FROM "dbrdf_reopened_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_reopened_delta_old";
        INSERT INTO "dbrdf_reopened_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_reopened_delta_new" t0;
        TRUNCATE TABLE "dbrdf_reopened_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1593
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_fuelSystem_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_fuelSystem_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28087;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_fuelSystem_delta_old" ON "dbrdf_fuelSystem_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_fuelSystem_delta_old" ON "dbrdf_fuelSystem_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_fuelSystem_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/fuelSystem$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/fuelSystem$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_fuelSystem_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_fuelSystem_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28087 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/fuelSystem$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/fuelSystem$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_fuelSystem_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_fuelSystem_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28087 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28087, t0.o FROM "dbrdf_fuelSystem_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_fuelSystem_delta_old";
        INSERT INTO "dbrdf_fuelSystem_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_fuelSystem_delta_new" t0;
        TRUNCATE TABLE "dbrdf_fuelSystem_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1594
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_games_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_games_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28088;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_games_delta_old" ON "dbrdf_games_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_games_delta_old" ON "dbrdf_games_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_games_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/games$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/games$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_games_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_games_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28088 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/games$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/games$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_games_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_games_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28088 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28088, t0.o FROM "dbrdf_games_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_games_delta_old";
        INSERT INTO "dbrdf_games_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_games_delta_new" t0;
        TRUNCATE TABLE "dbrdf_games_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1595
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_boilerPressure_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_boilerPressure_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28089;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_boilerPressure_delta_old" ON "dbrdf_boilerPressure_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_boilerPressure_delta_old" ON "dbrdf_boilerPressure_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_boilerPressure_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/boilerPressure$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/boilerPressure$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_boilerPressure_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_boilerPressure_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28089 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/boilerPressure$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/boilerPressure$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_boilerPressure_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_boilerPressure_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28089 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28089, t0.o FROM "dbrdf_boilerPressure_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_boilerPressure_delta_old";
        INSERT INTO "dbrdf_boilerPressure_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_boilerPressure_delta_new" t0;
        TRUNCATE TABLE "dbrdf_boilerPressure_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1596
    ---- DEPENDS ON: 1595, 701, 539, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Locomotive>(?X) :- <http://dbpedia.org/ontology/boilerPressure>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28090 FROM "__triples" t0 WHERE t0.p = 28089 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28090);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/Locomotive>(?X) :- <http://dbpedia.org/ontology/boiler>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28090 FROM "__triples" t0 WHERE t0.p = 27184 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28090);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/Locomotive>(?X) :- <http://dbpedia.org/ontology/cylinderCount>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28090 FROM "__triples" t0 WHERE t0.p = 27021 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28090);
    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_Locomotive_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Locomotive_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 28090;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Locomotive_delta_old" ON "dbrdf_Locomotive_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Locomotive_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/Locomotive$delta_new>(?Y) :- <http://dbpedia.org/ontology/Locomotive$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Locomotive_delta_new"(s) SELECT t1.o FROM "dbrdf_Locomotive_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 28090);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28090 FROM "dbrdf_Locomotive_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Locomotive_delta_old";
        INSERT INTO "dbrdf_Locomotive_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Locomotive_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Locomotive_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1597
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfPages_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfPages_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28091;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfPages_delta_old" ON "dbrdf_numberOfPages_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfPages_delta_old" ON "dbrdf_numberOfPages_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfPages_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/numberOfPages$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/numberOfPages$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_numberOfPages_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_numberOfPages_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28091 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/numberOfPages$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/numberOfPages$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_numberOfPages_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_numberOfPages_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28091 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28091, t0.o FROM "dbrdf_numberOfPages_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_numberOfPages_delta_old";
        INSERT INTO "dbrdf_numberOfPages_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfPages_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfPages_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1598
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_openingYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_openingYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28092;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_openingYear_delta_old" ON "dbrdf_openingYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_openingYear_delta_old" ON "dbrdf_openingYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_openingYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/openingYear$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/openingYear$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_openingYear_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_openingYear_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28092 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/openingYear$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/openingYear$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_openingYear_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_openingYear_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28092 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28092, t0.o FROM "dbrdf_openingYear_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_openingYear_delta_old";
        INSERT INTO "dbrdf_openingYear_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_openingYear_delta_new" t0;
        TRUNCATE TABLE "dbrdf_openingYear_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1599
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_suborbitalFlights_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_suborbitalFlights_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28093;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_suborbitalFlights_delta_old" ON "dbrdf_suborbitalFlights_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_suborbitalFlights_delta_old" ON "dbrdf_suborbitalFlights_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_suborbitalFlights_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/suborbitalFlights$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/suborbitalFlights$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_suborbitalFlights_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_suborbitalFlights_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28093 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/suborbitalFlights$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/suborbitalFlights$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_suborbitalFlights_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_suborbitalFlights_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28093 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28093, t0.o FROM "dbrdf_suborbitalFlights_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_suborbitalFlights_delta_old";
        INSERT INTO "dbrdf_suborbitalFlights_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_suborbitalFlights_delta_new" t0;
        TRUNCATE TABLE "dbrdf_suborbitalFlights_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1600
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_otherWins_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_otherWins_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28094;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_otherWins_delta_old" ON "dbrdf_otherWins_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_otherWins_delta_old" ON "dbrdf_otherWins_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_otherWins_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/otherWins$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/otherWins$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_otherWins_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_otherWins_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28094 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/otherWins$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/otherWins$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_otherWins_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_otherWins_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28094 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28094, t0.o FROM "dbrdf_otherWins_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_otherWins_delta_old";
        INSERT INTO "dbrdf_otherWins_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_otherWins_delta_new" t0;
        TRUNCATE TABLE "dbrdf_otherWins_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1601
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfSports_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfSports_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28095;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfSports_delta_old" ON "dbrdf_numberOfSports_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfSports_delta_old" ON "dbrdf_numberOfSports_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfSports_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/numberOfSports$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/numberOfSports$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_numberOfSports_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_numberOfSports_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28095 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/numberOfSports$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/numberOfSports$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_numberOfSports_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_numberOfSports_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28095 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28095, t0.o FROM "dbrdf_numberOfSports_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_numberOfSports_delta_old";
        INSERT INTO "dbrdf_numberOfSports_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfSports_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfSports_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1602
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_compressionRatio_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_compressionRatio_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28096;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_compressionRatio_delta_old" ON "dbrdf_compressionRatio_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_compressionRatio_delta_old" ON "dbrdf_compressionRatio_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_compressionRatio_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/compressionRatio$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/compressionRatio$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_compressionRatio_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_compressionRatio_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28096 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/compressionRatio$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/compressionRatio$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_compressionRatio_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_compressionRatio_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28096 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28096, t0.o FROM "dbrdf_compressionRatio_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_compressionRatio_delta_old";
        INSERT INTO "dbrdf_compressionRatio_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_compressionRatio_delta_new" t0;
        TRUNCATE TABLE "dbrdf_compressionRatio_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1603
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstAscentYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstAscentYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28097;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstAscentYear_delta_old" ON "dbrdf_firstAscentYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstAscentYear_delta_old" ON "dbrdf_firstAscentYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstAscentYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/firstAscentYear$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/firstAscentYear$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_firstAscentYear_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_firstAscentYear_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28097 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/firstAscentYear$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/firstAscentYear$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_firstAscentYear_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_firstAscentYear_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28097 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28097, t0.o FROM "dbrdf_firstAscentYear_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_firstAscentYear_delta_old";
        INSERT INTO "dbrdf_firstAscentYear_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_firstAscentYear_delta_new" t0;
        TRUNCATE TABLE "dbrdf_firstAscentYear_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1604
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_frequentlyUpdated_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_frequentlyUpdated_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28098;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_frequentlyUpdated_delta_old" ON "dbrdf_frequentlyUpdated_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_frequentlyUpdated_delta_old" ON "dbrdf_frequentlyUpdated_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_frequentlyUpdated_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/frequentlyUpdated$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/frequentlyUpdated$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_frequentlyUpdated_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_frequentlyUpdated_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28098 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/frequentlyUpdated$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/frequentlyUpdated$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_frequentlyUpdated_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_frequentlyUpdated_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28098 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28098, t0.o FROM "dbrdf_frequentlyUpdated_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_frequentlyUpdated_delta_old";
        INSERT INTO "dbrdf_frequentlyUpdated_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_frequentlyUpdated_delta_new" t0;
        TRUNCATE TABLE "dbrdf_frequentlyUpdated_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1605
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectCoordinator_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_projectCoordinator_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28099;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_projectCoordinator_delta_old" ON "dbrdf_projectCoordinator_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_projectCoordinator_delta_old" ON "dbrdf_projectCoordinator_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectCoordinator_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/projectCoordinator$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/projectCoordinator$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_projectCoordinator_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_projectCoordinator_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28099 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/projectCoordinator$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/projectCoordinator$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_projectCoordinator_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_projectCoordinator_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28099 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28099, t0.o FROM "dbrdf_projectCoordinator_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_projectCoordinator_delta_old";
        INSERT INTO "dbrdf_projectCoordinator_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_projectCoordinator_delta_new" t0;
        TRUNCATE TABLE "dbrdf_projectCoordinator_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1606
    ---- DEPENDS ON: 1605, 1533, 1418, 931, 901, 810, 543, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/ResearchProject>(?X) :- <http://dbpedia.org/ontology/fundedBy>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28100 FROM "__triples" t0 WHERE t0.p = 27908 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28100);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/ResearchProject>(?X) :- <http://dbpedia.org/ontology/projectBudgetTotal>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28100 FROM "__triples" t0 WHERE t0.p = 28024 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28100);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/ResearchProject>(?X) :- <http://dbpedia.org/ontology/projectType>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28100 FROM "__triples" t0 WHERE t0.p = 27415 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28100);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/ResearchProject>(?X) :- <http://dbpedia.org/ontology/projectCoordinator>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28100 FROM "__triples" t0 WHERE t0.p = 28099 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28100);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/ResearchProject>(?X) :- <http://dbpedia.org/ontology/projectReferenceID>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28100 FROM "__triples" t0 WHERE t0.p = 27293 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28100);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/ResearchProject>(?X) :- <http://dbpedia.org/ontology/projectBudgetFunding>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28100 FROM "__triples" t0 WHERE t0.p = 27025 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28100);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/ResearchProject>(?X) :- <http://dbpedia.org/ontology/projectParticipant>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28100 FROM "__triples" t0 WHERE t0.p = 27385 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28100);
    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_ResearchProject_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ResearchProject_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 28100;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ResearchProject_delta_old" ON "dbrdf_ResearchProject_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ResearchProject_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/ResearchProject$delta_new>(?Y) :- <http://dbpedia.org/ontology/ResearchProject$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_ResearchProject_delta_new"(s) SELECT t1.o FROM "dbrdf_ResearchProject_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 28100);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28100 FROM "dbrdf_ResearchProject_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_ResearchProject_delta_old";
        INSERT INTO "dbrdf_ResearchProject_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_ResearchProject_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ResearchProject_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1607
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_poleDriver_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_poleDriver_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28101;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_poleDriver_delta_old" ON "dbrdf_poleDriver_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_poleDriver_delta_old" ON "dbrdf_poleDriver_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_poleDriver_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/poleDriver$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/poleDriver$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_poleDriver_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_poleDriver_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28101 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/poleDriver$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/poleDriver$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_poleDriver_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_poleDriver_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28101 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28101, t0.o FROM "dbrdf_poleDriver_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_poleDriver_delta_old";
        INSERT INTO "dbrdf_poleDriver_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_poleDriver_delta_new" t0;
        TRUNCATE TABLE "dbrdf_poleDriver_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1608
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_wheelbase_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_wheelbase_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28102;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_wheelbase_delta_old0" ON "dbrdf_wheelbase_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_wheelbase_delta_old0" ON "dbrdf_wheelbase_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_wheelbase_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/Automobile/wheelbase$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Automobile/wheelbase$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_wheelbase_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_wheelbase_delta_old0" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28102 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/Automobile/wheelbase$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/Automobile/wheelbase$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_wheelbase_delta_new0"(s, o) SELECT t0.s, t1.o FROM "dbrdf_wheelbase_delta_old0" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28102 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28102, t0.o FROM "dbrdf_wheelbase_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_wheelbase_delta_old0";
        INSERT INTO "dbrdf_wheelbase_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_wheelbase_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_wheelbase_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1609
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_reportingMark_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_reportingMark_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28103;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_reportingMark_delta_old" ON "dbrdf_reportingMark_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_reportingMark_delta_old" ON "dbrdf_reportingMark_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_reportingMark_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/reportingMark$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/reportingMark$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_reportingMark_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_reportingMark_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28103 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/reportingMark$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/reportingMark$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_reportingMark_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_reportingMark_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28103 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28103, t0.o FROM "dbrdf_reportingMark_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_reportingMark_delta_old";
        INSERT INTO "dbrdf_reportingMark_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_reportingMark_delta_new" t0;
        TRUNCATE TABLE "dbrdf_reportingMark_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1610
    ---- DEPENDS ON: 1609, 1181, 651, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/PublicTransitSystem>(?X) :- <http://dbpedia.org/ontology/numberOfLines>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28104 FROM "__triples" t0 WHERE t0.p = 27667 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28104);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/PublicTransitSystem>(?X) :- <http://dbpedia.org/ontology/numberOfVehicles>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28104 FROM "__triples" t0 WHERE t0.p = 27133 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28104);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/PublicTransitSystem>(?X) :- <http://dbpedia.org/ontology/reportingMark>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28104 FROM "__triples" t0 WHERE t0.p = 28103 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28104);
    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_PublicTransitSystem_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_PublicTransitSystem_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 28104;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_PublicTransitSystem_delta_old" ON "dbrdf_PublicTransitSystem_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_PublicTransitSystem_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/PublicTransitSystem$delta_new>(?Y) :- <http://dbpedia.org/ontology/PublicTransitSystem$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_PublicTransitSystem_delta_new"(s) SELECT t1.o FROM "dbrdf_PublicTransitSystem_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 28104);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28104 FROM "dbrdf_PublicTransitSystem_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_PublicTransitSystem_delta_old";
        INSERT INTO "dbrdf_PublicTransitSystem_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_PublicTransitSystem_delta_new" t0;
        TRUNCATE TABLE "dbrdf_PublicTransitSystem_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1611
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_locatedInArea_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_locatedInArea_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28105;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_locatedInArea_delta_old" ON "dbrdf_locatedInArea_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_locatedInArea_delta_old" ON "dbrdf_locatedInArea_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_locatedInArea_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/locatedInArea$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/locatedInArea$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_locatedInArea_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_locatedInArea_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28105 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/locatedInArea$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/locatedInArea$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_locatedInArea_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_locatedInArea_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28105 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28105, t0.o FROM "dbrdf_locatedInArea_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_locatedInArea_delta_old";
        INSERT INTO "dbrdf_locatedInArea_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_locatedInArea_delta_new" t0;
        TRUNCATE TABLE "dbrdf_locatedInArea_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1612
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_relation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_relation_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28106;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_relation_delta_old" ON "dbrdf_relation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_relation_delta_old" ON "dbrdf_relation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_relation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/relation$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/relation$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_relation_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_relation_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28106 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/relation$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/relation$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_relation_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_relation_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28106 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28106, t0.o FROM "dbrdf_relation_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_relation_delta_old";
        INSERT INTO "dbrdf_relation_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_relation_delta_new" t0;
        TRUNCATE TABLE "dbrdf_relation_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1613
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_id_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_id_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28107;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_id_delta_old" ON "dbrdf_id_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_id_delta_old" ON "dbrdf_id_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_id_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/id$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/id$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_id_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_id_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28107 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/id$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/id$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_id_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_id_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28107 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28107, t0.o FROM "dbrdf_id_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_id_delta_old";
        INSERT INTO "dbrdf_id_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_id_delta_new" t0;
        TRUNCATE TABLE "dbrdf_id_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1614
    ---- DEPENDS ON: 1613, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/WorldHeritageSite>(?X) :- <http://dbpedia.org/ontology/id>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28108 FROM "__triples" t0 WHERE t0.p = 28107 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28108);
    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_WorldHeritageSite_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_WorldHeritageSite_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 28108;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_WorldHeritageSite_delta_old" ON "dbrdf_WorldHeritageSite_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_WorldHeritageSite_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/WorldHeritageSite$delta_new>(?Y) :- <http://dbpedia.org/ontology/WorldHeritageSite$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_WorldHeritageSite_delta_new"(s) SELECT t1.o FROM "dbrdf_WorldHeritageSite_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 28108);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28108 FROM "dbrdf_WorldHeritageSite_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_WorldHeritageSite_delta_old";
        INSERT INTO "dbrdf_WorldHeritageSite_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_WorldHeritageSite_delta_new" t0;
        TRUNCATE TABLE "dbrdf_WorldHeritageSite_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1615
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_university_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_university_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28109;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_university_delta_old" ON "dbrdf_university_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_university_delta_old" ON "dbrdf_university_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_university_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/university$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/university$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_university_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_university_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28109 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/university$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/university$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_university_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_university_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28109 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28109, t0.o FROM "dbrdf_university_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_university_delta_old";
        INSERT INTO "dbrdf_university_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_university_delta_new" t0;
        TRUNCATE TABLE "dbrdf_university_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1616
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_englishName_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_englishName_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28110;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_englishName_delta_old" ON "dbrdf_englishName_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_englishName_delta_old" ON "dbrdf_englishName_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_englishName_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/englishName$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/englishName$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_englishName_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_englishName_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28110 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/englishName$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/englishName$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_englishName_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_englishName_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28110 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28110, t0.o FROM "dbrdf_englishName_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_englishName_delta_old";
        INSERT INTO "dbrdf_englishName_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_englishName_delta_new" t0;
        TRUNCATE TABLE "dbrdf_englishName_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1617
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_chain_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_chain_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28111;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_chain_delta_old" ON "dbrdf_chain_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_chain_delta_old" ON "dbrdf_chain_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_chain_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/chain$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/chain$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_chain_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_chain_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28111 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/chain$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/chain$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_chain_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_chain_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28111 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28111, t0.o FROM "dbrdf_chain_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_chain_delta_old";
        INSERT INTO "dbrdf_chain_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_chain_delta_new" t0;
        TRUNCATE TABLE "dbrdf_chain_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1618
    ---- DEPENDS ON: 1617, 1344, 1223, 1151, 378, 338, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Hotel>(?X) :- <http://dbpedia.org/ontology/chain>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28113 FROM "__triples" t0 WHERE t0.p = 28111 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28113);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/Hotel>(?X) :- <http://dbpedia.org/ontology/numberOfRestaurants>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28113 FROM "__triples" t0 WHERE t0.p = 27709 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28113);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/Hotel>(?X) :- <http://dbpedia.org/ontology/numberOfRooms>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28113 FROM "__triples" t0 WHERE t0.p = 27637 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28113);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/Hotel>(?X) :- <http://dbpedia.org/ontology/starRating>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28113 FROM "__triples" t0 WHERE t0.p = 26860 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28113);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/Hotel>(?X) :- <http://dbpedia.org/ontology/numberOfParkingSpaces>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28113 FROM "__triples" t0 WHERE t0.p = 27834 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28113);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/Hotel>(?X) :- <http://dbpedia.org/ontology/numberOfSuites>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28113 FROM "__triples" t0 WHERE t0.p = 26820 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28113);
    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_Hotel_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Hotel_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 28112;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Hotel_delta_old" ON "dbrdf_Hotel_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Hotel_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Hotel_delta_old0"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Hotel_delta_old0"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 28113;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Hotel_delta_old0" ON "dbrdf_Hotel_delta_old0"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Hotel_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/Hotel$delta_new>(?X) :- <http://dbpedia.org/ontology/Hotel$delta_old>(?X) .
        INSERT INTO "dbrdf_Hotel_delta_new"(s) SELECT t0.s FROM "dbrdf_Hotel_delta_old0" t0 WHERE NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28112);


        -- <http://schema.org/Hotel$delta_new>(?Y) :- <http://schema.org/Hotel$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Hotel_delta_new"(s) SELECT t1.o FROM "dbrdf_Hotel_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 28112);


        -- <http://dbpedia.org/ontology/Hotel$delta_new>(?X) :- <http://schema.org/Hotel$delta_old>(?X) .
        INSERT INTO "dbrdf_Hotel_delta_new0"(s) SELECT t0.s FROM "dbrdf_Hotel_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28113);


        -- <http://dbpedia.org/ontology/Hotel$delta_new>(?Y) :- <http://dbpedia.org/ontology/Hotel$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Hotel_delta_new0"(s) SELECT t1.o FROM "dbrdf_Hotel_delta_old0" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 28113);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28112 FROM "dbrdf_Hotel_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Hotel_delta_old";
        INSERT INTO "dbrdf_Hotel_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Hotel_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Hotel_delta_new";

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28113 FROM "dbrdf_Hotel_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_Hotel_delta_old0";
        INSERT INTO "dbrdf_Hotel_delta_old0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Hotel_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_Hotel_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1619
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_geneLocation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_geneLocation_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28114;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_geneLocation_delta_old" ON "dbrdf_geneLocation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_geneLocation_delta_old" ON "dbrdf_geneLocation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_geneLocation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/geneLocation$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/geneLocation$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_geneLocation_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_geneLocation_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28114 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/geneLocation$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/geneLocation$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_geneLocation_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_geneLocation_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28114 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28114, t0.o FROM "dbrdf_geneLocation_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_geneLocation_delta_old";
        INSERT INTO "dbrdf_geneLocation_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_geneLocation_delta_new" t0;
        TRUNCATE TABLE "dbrdf_geneLocation_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1620
    ---- DEPENDS ON: 1619, 1221, 1130, 944, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Gene>(?X) :- <http://dbpedia.org/ontology/geneLocation>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28115 FROM "__triples" t0 WHERE t0.p = 28114 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28115);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/Gene>(?X) :- <http://dbpedia.org/ontology/orthologousGene>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28115 FROM "__triples" t0 WHERE t0.p = 27707 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28115);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/Gene>(?X) :- <http://dbpedia.org/ontology/MouseGene>(?X) .
    INSERT INTO "__triples"(s, p, o) SELECT t0.s, 2, 28115 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27616 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28115);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/Gene>(?X) :- <http://dbpedia.org/ontology/HumanGene>(?X) .
    INSERT INTO "__triples"(s, p, o) SELECT t0.s, 2, 28115 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27429 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28115);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/Gene>(?X1) :- <http://dbpedia.org/ontology/orthologousGene>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.o, 2, 28115 FROM "__triples" t0 WHERE t0.p = 27707 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.o AND ex.p = 2 AND ex.o = 28115);
    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_Gene_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Gene_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 28115;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Gene_delta_old" ON "dbrdf_Gene_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Gene_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/Gene$delta_new>(?Y) :- <http://dbpedia.org/ontology/Gene$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Gene_delta_new"(s) SELECT t1.o FROM "dbrdf_Gene_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 28115);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28115 FROM "dbrdf_Gene_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Gene_delta_old";
        INSERT INTO "dbrdf_Gene_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Gene_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Gene_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1621
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ethnicGroup_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ethnicGroup_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28116;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ethnicGroup_delta_old" ON "dbrdf_ethnicGroup_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ethnicGroup_delta_old" ON "dbrdf_ethnicGroup_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ethnicGroup_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/ethnicGroup$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/ethnicGroup$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_ethnicGroup_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_ethnicGroup_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 28116 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/ethnicGroup$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/ethnicGroup$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_ethnicGroup_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_ethnicGroup_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 28116 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28116, t0.o FROM "dbrdf_ethnicGroup_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_ethnicGroup_delta_old";
        INSERT INTO "dbrdf_ethnicGroup_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_ethnicGroup_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ethnicGroup_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1622
    ---- DEPENDS ON: 1621, 1104, 748, 246, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/EthnicGroup>(?X1) :- <http://dbpedia.org/ontology/ethnicGroup>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.o, 2, 28117 FROM "__triples" t0 WHERE t0.p = 28116 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.o AND ex.p = 2 AND ex.o = 28117);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/EthnicGroup>(?X) :- <http://dbpedia.org/ontology/totalPopulation>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28117 FROM "__triples" t0 WHERE t0.p = 27590 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28117);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/EthnicGroup>(?X) :- <http://dbpedia.org/ontology/populationPlace>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28117 FROM "__triples" t0 WHERE t0.p = 26728 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28117);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/EthnicGroup>(?X1) :- <http://dbpedia.org/ontology/ethnicity>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.o, 2, 28117 FROM "__triples" t0 WHERE t0.p = 27231 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.o AND ex.p = 2 AND ex.o = 28117);
    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_EthnicGroup_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_EthnicGroup_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 28117;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_EthnicGroup_delta_old" ON "dbrdf_EthnicGroup_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_EthnicGroup_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/EthnicGroup$delta_new>(?Y) :- <http://dbpedia.org/ontology/EthnicGroup$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_EthnicGroup_delta_new"(s) SELECT t1.o FROM "dbrdf_EthnicGroup_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 28117);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28117 FROM "dbrdf_EthnicGroup_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_EthnicGroup_delta_old";
        INSERT INTO "dbrdf_EthnicGroup_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_EthnicGroup_delta_new" t0;
        TRUNCATE TABLE "dbrdf_EthnicGroup_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1623
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_neighboringMunicipality_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_neighboringMunicipality_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28118;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_neighboringMunicipality_delta_old" ON "dbrdf_neighboringMunicipality_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_neighboringMunicipality_delta_old" ON "dbrdf_neighboringMunicipality_delta_old"(o);
