        TRUNCATE TABLE "dbrdf_composer_delta_old";
        INSERT INTO "dbrdf_composer_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_composer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_composer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1306
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_minimumElevation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_minimumElevation_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27796;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_minimumElevation_delta_old" ON "dbrdf_minimumElevation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_minimumElevation_delta_old" ON "dbrdf_minimumElevation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_minimumElevation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/minimumElevation$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/minimumElevation$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_minimumElevation_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_minimumElevation_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 = 27796 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/minimumElevation$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/minimumElevation$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_minimumElevation_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_minimumElevation_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 = 27796 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1307
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cargoFuel_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cargoFuel_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27797;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cargoFuel_delta_old0" ON "dbrdf_cargoFuel_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_cargoFuel_delta_old0" ON "dbrdf_cargoFuel_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cargoFuel_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Spacecraft/cargoFuel$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Spacecraft/cargoFuel$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_cargoFuel_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_cargoFuel_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 = 27797 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/Spacecraft/cargoFuel$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/Spacecraft/cargoFuel$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_cargoFuel_delta_new0"(s, o) SELECT t0.s, t1.o FROM "dbrdf_cargoFuel_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 = 27797 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27797, t0.o FROM "dbrdf_cargoFuel_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_cargoFuel_delta_old0";
        INSERT INTO "dbrdf_cargoFuel_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cargoFuel_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_cargoFuel_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1308
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_team_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_team_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27798;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_team_delta_old" ON "dbrdf_team_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_team_delta_old" ON "dbrdf_team_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_team_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/team$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/team$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_team_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_team_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 = 27798 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/team$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/team$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_team_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_team_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 = 27798 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1309
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_producer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_producer_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27799;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_producer_delta_old" ON "dbrdf_producer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_producer_delta_old" ON "dbrdf_producer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_producer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/producer$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/producer$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_producer_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_producer_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 = 27799 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/producer$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/producer$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_producer_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_producer_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 = 27799 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1310
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_destructionDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_destructionDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27800;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_destructionDate_delta_old" ON "dbrdf_destructionDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_destructionDate_delta_old" ON "dbrdf_destructionDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_destructionDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/destructionDate$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/destructionDate$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_destructionDate_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_destructionDate_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 = 27800 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/destructionDate$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/destructionDate$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_destructionDate_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_destructionDate_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 = 27800 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1311
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsSoiusaCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_alpsSoiusaCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27801;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_alpsSoiusaCode_delta_old" ON "dbrdf_alpsSoiusaCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_alpsSoiusaCode_delta_old" ON "dbrdf_alpsSoiusaCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsSoiusaCode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/alpsSoiusaCode$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/alpsSoiusaCode$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_alpsSoiusaCode_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_alpsSoiusaCode_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 = 27801 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/alpsSoiusaCode$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/alpsSoiusaCode$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_alpsSoiusaCode_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_alpsSoiusaCode_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 = 27801 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1312
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_managementElevation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_managementElevation_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27802;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_managementElevation_delta_old" ON "dbrdf_managementElevation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_managementElevation_delta_old" ON "dbrdf_managementElevation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_managementElevation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/managementElevation$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/managementElevation$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_managementElevation_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_managementElevation_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 = 27802 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/managementElevation$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/managementElevation$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_managementElevation_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_managementElevation_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 = 27802 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1313
    ---- 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 = 27803;
    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 = 27803 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 = 27803 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_floorArea_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_floorArea_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27804;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_floorArea_delta_old" ON "dbrdf_floorArea_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_floorArea_delta_old" ON "dbrdf_floorArea_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_floorArea_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/floorArea$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/floorArea$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_floorArea_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_floorArea_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 = 27804 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/floorArea$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/floorArea$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_floorArea_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_floorArea_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 = 27804 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1315
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_musicFusionGenre_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_musicFusionGenre_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27805;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_musicFusionGenre_delta_old" ON "dbrdf_musicFusionGenre_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_musicFusionGenre_delta_old" ON "dbrdf_musicFusionGenre_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_musicFusionGenre_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/musicFusionGenre$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/musicFusionGenre$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_musicFusionGenre_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_musicFusionGenre_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 = 27805 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/musicFusionGenre$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/musicFusionGenre$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_musicFusionGenre_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_musicFusionGenre_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 = 27805 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1316
    ---- DEPENDS ON: 1315, 792, 501, 101, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/MusicGenre>(?X1) :- <http://dbpedia.org/ontology/musicSubgenre>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.o, 2, 27806 FROM "__triples" t0 WHERE t0.p = 26583 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.o AND ex.p = 2 AND ex.o = 27806);
    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_MusicGenre_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_MusicGenre_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27806;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_MusicGenre_delta_old" ON "dbrdf_MusicGenre_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_MusicGenre_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/MusicGenre$delta_new>(?Y) :- <http://dbpedia.org/ontology/MusicGenre$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_MusicGenre_delta_new"(s) SELECT t1.o FROM "dbrdf_MusicGenre_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 = 27806);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1317
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_managerClub_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_managerClub_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27807;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_managerClub_delta_old" ON "dbrdf_managerClub_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_managerClub_delta_old" ON "dbrdf_managerClub_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_managerClub_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/managerClub$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/managerClub$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_managerClub_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_managerClub_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 = 27807 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/managerClub$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/managerClub$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_managerClub_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_managerClub_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 = 27807 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1318
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_interest_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_interest_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27808;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_interest_delta_old" ON "dbrdf_interest_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_interest_delta_old" ON "dbrdf_interest_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_interest_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/interest$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/interest$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_interest_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_interest_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 = 27808 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/interest$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/interest$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_interest_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_interest_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 = 27808 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1319
    ---- DEPENDS ON: 1318, 857, 782, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

    -- [Rule] <http://dbpedia.org/ontology/SiteOfSpecialScientificInterest>(?X) :- <http://dbpedia.org/ontology/areaOfSearch>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27809 FROM "__triples" t0 WHERE t0.p = 27267 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27809);
    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_SiteOfSpecialScientificInterest_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SiteOfSpecialScientificInterest_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27809;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SiteOfSpecialScientificInterest_delta_old" ON "dbrdf_SiteOfSpecialScientificInterest_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SiteOfSpecialScientificInterest_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/SiteOfSpecialScientificInterest$delta_new>(?Y) :- <http://dbpedia.org/ontology/SiteOfSpecialScientificInterest$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_SiteOfSpecialScientificInterest_delta_new"(s) SELECT t1.o FROM "dbrdf_SiteOfSpecialScientificInterest_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 = 27809);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1320
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceState_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sourceState_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27810;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sourceState_delta_old" ON "dbrdf_sourceState_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sourceState_delta_old" ON "dbrdf_sourceState_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceState_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/sourceState$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/sourceState$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_sourceState_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_sourceState_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 = 27810 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/sourceState$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/sourceState$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_sourceState_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_sourceState_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 = 27810 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1321
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtSun_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtSun_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27811;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtSun_delta_old" ON "dbrdf_winsAtSun_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtSun_delta_old" ON "dbrdf_winsAtSun_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtSun_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/winsAtSun$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/winsAtSun$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_winsAtSun_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_winsAtSun_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 = 27811 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/winsAtSun$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/winsAtSun$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_winsAtSun_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_winsAtSun_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 = 27811 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1322
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_secondLeader_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_secondLeader_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27812;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_secondLeader_delta_old" ON "dbrdf_secondLeader_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_secondLeader_delta_old" ON "dbrdf_secondLeader_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_secondLeader_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/secondLeader$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/secondLeader$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_secondLeader_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_secondLeader_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 = 27812 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/secondLeader$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/secondLeader$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_secondLeader_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_secondLeader_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 = 27812 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1323
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_americanComedyAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_americanComedyAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27813;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_americanComedyAward_delta_old" ON "dbrdf_americanComedyAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_americanComedyAward_delta_old" ON "dbrdf_americanComedyAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_americanComedyAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/americanComedyAward$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/americanComedyAward$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_americanComedyAward_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_americanComedyAward_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 = 27813 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/americanComedyAward$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/americanComedyAward$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_americanComedyAward_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_americanComedyAward_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 = 27813 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1324
    ---- DEPENDS ON: 1323, 1057, 371, 129, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Comedian>(?X) :- <http://dbpedia.org/ontology/olivierAward>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27814 FROM "__triples" t0 WHERE t0.p = 26611 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27814);
    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_Comedian_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Comedian_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27814;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Comedian_delta_old" ON "dbrdf_Comedian_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Comedian_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/Comedian$delta_new>(?Y) :- <http://dbpedia.org/ontology/Comedian$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Comedian_delta_new"(s) SELECT t1.o FROM "dbrdf_Comedian_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 = 27814);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1325
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceConfluencePosition_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sourceConfluencePosition_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27815;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sourceConfluencePosition_delta_old" ON "dbrdf_sourceConfluencePosition_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sourceConfluencePosition_delta_old" ON "dbrdf_sourceConfluencePosition_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceConfluencePosition_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/sourceConfluencePosition$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/sourceConfluencePosition$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_sourceConfluencePosition_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_sourceConfluencePosition_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 = 27815 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/sourceConfluencePosition$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/sourceConfluencePosition$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_sourceConfluencePosition_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_sourceConfluencePosition_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 = 27815 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1326
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerTeam_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_formerTeam_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27816;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_formerTeam_delta_old" ON "dbrdf_formerTeam_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_formerTeam_delta_old" ON "dbrdf_formerTeam_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerTeam_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/formerTeam$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/formerTeam$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_formerTeam_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_formerTeam_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 = 27816 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/formerTeam$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/formerTeam$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_formerTeam_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_formerTeam_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 = 27816 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1327
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nationality_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nationality_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27817;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nationality_delta_old" ON "dbrdf_nationality_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nationality_delta_old" ON "dbrdf_nationality_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nationality_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/nationality$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/nationality$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_nationality_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_nationality_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 = 27817 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/nationality$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/nationality$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_nationality_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_nationality_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 = 27817 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1328
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_award_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_award_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27818;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_award_delta_old" ON "dbrdf_award_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_award_delta_old" ON "dbrdf_award_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_award_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/award$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/award$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_award_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_award_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 = 27818 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/award$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/award$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_award_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_award_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 = 27818 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1329
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_startYearOfInsertion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_startYearOfInsertion_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27819;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_startYearOfInsertion_delta_old" ON "dbrdf_startYearOfInsertion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_startYearOfInsertion_delta_old" ON "dbrdf_startYearOfInsertion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_startYearOfInsertion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/startYearOfInsertion$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/startYearOfInsertion$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_startYearOfInsertion_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_startYearOfInsertion_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 = 27819 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/startYearOfInsertion$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/startYearOfInsertion$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_startYearOfInsertion_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_startYearOfInsertion_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 = 27819 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1330
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_trainerYears_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_trainerYears_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27820;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_trainerYears_delta_old" ON "dbrdf_trainerYears_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_trainerYears_delta_old" ON "dbrdf_trainerYears_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_trainerYears_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/trainerYears$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/trainerYears$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_trainerYears_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_trainerYears_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 = 27820 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/trainerYears$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/trainerYears$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_trainerYears_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_trainerYears_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 = 27820 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/SportsTeamMember>(?X) :- <http://dbpedia.org/ontology/squadNumber>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27821 FROM "__triples" t0 WHERE t0.p = 27405 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27821);
    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_SportsTeamMember_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SportsTeamMember_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27821;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SportsTeamMember_delta_old" ON "dbrdf_SportsTeamMember_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SportsTeamMember_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/SportsTeamMember$delta_new>(?Y) :- <http://dbpedia.org/ontology/SportsTeamMember$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_SportsTeamMember_delta_new"(s) SELECT t1.o FROM "dbrdf_SportsTeamMember_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 = 27821);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1332
    ---- DEPENDS ON: 1331, 895, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- [Rule] <http://dbpedia.org/ontology/OrganisationMember>(?X1) :- <http://dbpedia.org/ontology/organisationMember>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.o, 2, 27822 FROM "__triples" t0 WHERE t0.p = 27382 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.o AND ex.p = 2 AND ex.o = 27822);
    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_OrganisationMember_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_OrganisationMember_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27822;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_OrganisationMember_delta_old" ON "dbrdf_OrganisationMember_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_OrganisationMember_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/OrganisationMember$delta_new>(?Y) :- <http://dbpedia.org/ontology/OrganisationMember$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_OrganisationMember_delta_new"(s) SELECT t1.o FROM "dbrdf_OrganisationMember_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 = 27822);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1333
    ---- 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 = 27823;
    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 = 27823 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 = 27823 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27823, 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 1334
    ---- 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 = 27824;
    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 = 27824 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 = 27824 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cmykCoordinateBlack_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cmykCoordinateBlack_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27825;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cmykCoordinateBlack_delta_old" ON "dbrdf_cmykCoordinateBlack_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_cmykCoordinateBlack_delta_old" ON "dbrdf_cmykCoordinateBlack_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cmykCoordinateBlack_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/cmykCoordinateBlack$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/cmykCoordinateBlack$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_cmykCoordinateBlack_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_cmykCoordinateBlack_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 = 27825 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/cmykCoordinateBlack$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/cmykCoordinateBlack$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_cmykCoordinateBlack_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_cmykCoordinateBlack_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 = 27825 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1336
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nrhpType_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nrhpType_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27826;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nrhpType_delta_old" ON "dbrdf_nrhpType_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nrhpType_delta_old" ON "dbrdf_nrhpType_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nrhpType_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/nrhpType$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/nrhpType$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_nrhpType_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_nrhpType_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 = 27826 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/nrhpType$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/nrhpType$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_nrhpType_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_nrhpType_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 = 27826 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1337
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_accessDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_accessDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27827;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_accessDate_delta_old" ON "dbrdf_accessDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_accessDate_delta_old" ON "dbrdf_accessDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_accessDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/accessDate$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/accessDate$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_accessDate_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_accessDate_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 = 27827 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/accessDate$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/accessDate$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_accessDate_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_accessDate_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 = 27827 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1338
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_goalsInLeague_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_goalsInLeague_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27828;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_goalsInLeague_delta_old" ON "dbrdf_goalsInLeague_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_goalsInLeague_delta_old" ON "dbrdf_goalsInLeague_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_goalsInLeague_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/goalsInLeague$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/goalsInLeague$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_goalsInLeague_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_goalsInLeague_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 = 27828 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/goalsInLeague$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/goalsInLeague$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_goalsInLeague_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_goalsInLeague_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 = 27828 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1339
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_oclc_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_oclc_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27829;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_oclc_delta_old" ON "dbrdf_oclc_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_oclc_delta_old" ON "dbrdf_oclc_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_oclc_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/oclc$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/oclc$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_oclc_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_oclc_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 = 27829 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/oclc$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/oclc$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_oclc_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_oclc_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 = 27829 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1340
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_hasJunctionWith_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_hasJunctionWith_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27830;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_hasJunctionWith_delta_old" ON "dbrdf_hasJunctionWith_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_hasJunctionWith_delta_old" ON "dbrdf_hasJunctionWith_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_hasJunctionWith_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/hasJunctionWith$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/hasJunctionWith$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_hasJunctionWith_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_hasJunctionWith_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 = 27830 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/hasJunctionWith$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/hasJunctionWith$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_hasJunctionWith_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_hasJunctionWith_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 = 27830 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1341
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_RugbyPlayer_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_RugbyPlayer_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27831;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_RugbyPlayer_delta_old" ON "dbrdf_RugbyPlayer_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_RugbyPlayer_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/RugbyPlayer$delta_new>(?Y) :- <http://dbpedia.org/ontology/RugbyPlayer$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_RugbyPlayer_delta_new"(s) SELECT t1.o FROM "dbrdf_RugbyPlayer_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 = 27831);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1342
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lyrics_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lyrics_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27832;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lyrics_delta_old" ON "dbrdf_lyrics_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lyrics_delta_old" ON "dbrdf_lyrics_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lyrics_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/lyrics$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/lyrics$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_lyrics_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_lyrics_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 = 27832 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/lyrics$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/lyrics$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_lyrics_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_lyrics_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 = 27832 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1343
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_chaplain_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_chaplain_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27833;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_chaplain_delta_old" ON "dbrdf_chaplain_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_chaplain_delta_old" ON "dbrdf_chaplain_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_chaplain_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/chaplain$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/chaplain$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_chaplain_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_chaplain_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 = 27833 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/chaplain$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/chaplain$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_chaplain_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_chaplain_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 = 27833 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1344
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_network_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_network_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27834;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_network_delta_old" ON "dbrdf_network_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_network_delta_old" ON "dbrdf_network_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_network_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/network$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/network$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_network_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_network_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 = 27834 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/network$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/network$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_network_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_network_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 = 27834 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1345
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_municipalityType_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_municipalityType_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27835;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_municipalityType_delta_old" ON "dbrdf_municipalityType_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_municipalityType_delta_old" ON "dbrdf_municipalityType_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_municipalityType_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/municipalityType$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/municipalityType$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_municipalityType_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_municipalityType_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 = 27835 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/municipalityType$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/municipalityType$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_municipalityType_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_municipalityType_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 = 27835 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1346
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastElectionDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lastElectionDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27836;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lastElectionDate_delta_old" ON "dbrdf_lastElectionDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lastElectionDate_delta_old" ON "dbrdf_lastElectionDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastElectionDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/lastElectionDate$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/lastElectionDate$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_lastElectionDate_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_lastElectionDate_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 = 27836 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/lastElectionDate$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/lastElectionDate$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_lastElectionDate_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_lastElectionDate_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 = 27836 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1347
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_distributingLabel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_distributingLabel_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27837;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_distributingLabel_delta_old" ON "dbrdf_distributingLabel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_distributingLabel_delta_old" ON "dbrdf_distributingLabel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_distributingLabel_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/distributingLabel$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/distributingLabel$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_distributingLabel_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_distributingLabel_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 = 27837 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/distributingLabel$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/distributingLabel$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_distributingLabel_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_distributingLabel_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 = 27837 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1348
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aSide_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aSide_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27838;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aSide_delta_old" ON "dbrdf_aSide_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aSide_delta_old" ON "dbrdf_aSide_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aSide_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/aSide$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/aSide$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_aSide_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_aSide_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 = 27838 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/aSide$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/aSide$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_aSide_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_aSide_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 = 27838 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1349
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_closingDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_closingDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27839;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_closingDate_delta_old" ON "dbrdf_closingDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_closingDate_delta_old" ON "dbrdf_closingDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_closingDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/closingDate$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/closingDate$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_closingDate_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_closingDate_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 = 27839 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/closingDate$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/closingDate$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_closingDate_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_closingDate_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 = 27839 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1350
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfPlatformLevels_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfPlatformLevels_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27840;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfPlatformLevels_delta_old" ON "dbrdf_numberOfPlatformLevels_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfPlatformLevels_delta_old" ON "dbrdf_numberOfPlatformLevels_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfPlatformLevels_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/numberOfPlatformLevels$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/numberOfPlatformLevels$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_numberOfPlatformLevels_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_numberOfPlatformLevels_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 = 27840 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/numberOfPlatformLevels$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/numberOfPlatformLevels$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_numberOfPlatformLevels_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_numberOfPlatformLevels_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 = 27840 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1351
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_endangeredSince_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_endangeredSince_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27841;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_endangeredSince_delta_old" ON "dbrdf_endangeredSince_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_endangeredSince_delta_old" ON "dbrdf_endangeredSince_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_endangeredSince_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/endangeredSince$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/endangeredSince$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_endangeredSince_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_endangeredSince_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 = 27841 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/endangeredSince$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/endangeredSince$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_endangeredSince_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_endangeredSince_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 = 27841 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1352
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_geminiAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_geminiAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27842;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_geminiAward_delta_old" ON "dbrdf_geminiAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_geminiAward_delta_old" ON "dbrdf_geminiAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_geminiAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/geminiAward$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/geminiAward$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_geminiAward_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_geminiAward_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 = 27842 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/geminiAward$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/geminiAward$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_geminiAward_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_geminiAward_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 = 27842 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1353
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nationalYears_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nationalYears_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27843;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nationalYears_delta_old" ON "dbrdf_nationalYears_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nationalYears_delta_old" ON "dbrdf_nationalYears_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nationalYears_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/nationalYears$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/nationalYears$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_nationalYears_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_nationalYears_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 = 27843 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/nationalYears$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/nationalYears$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_nationalYears_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_nationalYears_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 = 27843 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1354
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_structuralSystem_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_structuralSystem_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27844;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_structuralSystem_delta_old" ON "dbrdf_structuralSystem_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_structuralSystem_delta_old" ON "dbrdf_structuralSystem_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_structuralSystem_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/structuralSystem$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/structuralSystem$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_structuralSystem_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_structuralSystem_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 = 27844 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/structuralSystem$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/structuralSystem$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_structuralSystem_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_structuralSystem_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 = 27844 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1355
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_shareSource_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_shareSource_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27845;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_shareSource_delta_old" ON "dbrdf_shareSource_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_shareSource_delta_old" ON "dbrdf_shareSource_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_shareSource_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/shareSource$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/shareSource$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_shareSource_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_shareSource_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 = 27845 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/shareSource$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/shareSource$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_shareSource_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_shareSource_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 = 27845 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1356
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_distance_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_distance_delta_old1"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27846;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_distance_delta_old1" ON "dbrdf_distance_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_distance_delta_old1" ON "dbrdf_distance_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_distance_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/SpaceShuttle/distance$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/SpaceShuttle/distance$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_distance_delta_new1"(s, o) SELECT t1.o, t0.o FROM "dbrdf_distance_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 = 27846 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/SpaceShuttle/distance$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/SpaceShuttle/distance$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_distance_delta_new1"(s, o) SELECT t0.s, t1.o FROM "dbrdf_distance_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 = 27846 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27846, t0.o FROM "dbrdf_distance_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_distance_delta_old1";
        INSERT INTO "dbrdf_distance_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_distance_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_distance_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1357
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_binomial_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_binomial_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27847;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_binomial_delta_old" ON "dbrdf_binomial_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_binomial_delta_old" ON "dbrdf_binomial_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_binomial_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/binomial$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/binomial$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_binomial_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_binomial_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 = 27847 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/binomial$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/binomial$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_binomial_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_binomial_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 = 27847 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1358
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_elevation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_elevation_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27848;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_elevation_delta_old" ON "dbrdf_elevation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_elevation_delta_old" ON "dbrdf_elevation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_elevation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/elevation$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/elevation$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_elevation_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_elevation_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 = 27848 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/elevation$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/elevation$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_elevation_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_elevation_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 = 27848 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1359
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_summerAppearances_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_summerAppearances_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27849;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_summerAppearances_delta_old" ON "dbrdf_summerAppearances_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_summerAppearances_delta_old" ON "dbrdf_summerAppearances_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_summerAppearances_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/summerAppearances$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/summerAppearances$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_summerAppearances_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_summerAppearances_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 = 27849 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/summerAppearances$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/summerAppearances$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_summerAppearances_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_summerAppearances_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 = 27849 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1360
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Ambassador_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Ambassador_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27850;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Ambassador_delta_old" ON "dbrdf_Ambassador_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Ambassador_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/Ambassador$delta_new>(?Y) :- <http://dbpedia.org/ontology/Ambassador$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Ambassador_delta_new"(s) SELECT t1.o FROM "dbrdf_Ambassador_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 = 27850);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1361
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsMainPart_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_alpsMainPart_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27851;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_alpsMainPart_delta_old" ON "dbrdf_alpsMainPart_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_alpsMainPart_delta_old" ON "dbrdf_alpsMainPart_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsMainPart_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/alpsMainPart$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/alpsMainPart$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_alpsMainPart_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_alpsMainPart_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 = 27851 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/alpsMainPart$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/alpsMainPart$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_alpsMainPart_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_alpsMainPart_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 = 27851 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1362
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_latestReleaseDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_latestReleaseDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27852;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_latestReleaseDate_delta_old" ON "dbrdf_latestReleaseDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_latestReleaseDate_delta_old" ON "dbrdf_latestReleaseDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_latestReleaseDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/latestReleaseDate$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/latestReleaseDate$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_latestReleaseDate_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_latestReleaseDate_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 = 27852 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/latestReleaseDate$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/latestReleaseDate$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_latestReleaseDate_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_latestReleaseDate_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 = 27852 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1363
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lowest_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lowest_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27853;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lowest_delta_old" ON "dbrdf_lowest_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lowest_delta_old" ON "dbrdf_lowest_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lowest_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/lowest$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/lowest$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_lowest_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_lowest_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 = 27853 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/lowest$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/lowest$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_lowest_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_lowest_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 = 27853 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1364
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_waterwayThroughTunnel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_waterwayThroughTunnel_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27854;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_waterwayThroughTunnel_delta_old" ON "dbrdf_waterwayThroughTunnel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_waterwayThroughTunnel_delta_old" ON "dbrdf_waterwayThroughTunnel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_waterwayThroughTunnel_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/waterwayThroughTunnel$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/waterwayThroughTunnel$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_waterwayThroughTunnel_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_waterwayThroughTunnel_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 = 27854 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/waterwayThroughTunnel$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/waterwayThroughTunnel$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_waterwayThroughTunnel_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_waterwayThroughTunnel_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 = 27854 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1365
    ---- DEPENDS ON: 1364, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/WaterwayTunnel>(?X) :- <http://dbpedia.org/ontology/waterwayThroughTunnel>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27855 FROM "__triples" t0 WHERE t0.p = 27854 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27855);
    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_WaterwayTunnel_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_WaterwayTunnel_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27855;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_WaterwayTunnel_delta_old" ON "dbrdf_WaterwayTunnel_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_WaterwayTunnel_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/WaterwayTunnel$delta_new>(?Y) :- <http://dbpedia.org/ontology/WaterwayTunnel$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_WaterwayTunnel_delta_new"(s) SELECT t1.o FROM "dbrdf_WaterwayTunnel_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 = 27855);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1366
    ---- DEPENDS ON: 1365, 429, 610, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

    -- [Rule] <http://dbpedia.org/ontology/Tunnel>(?X) :- <http://dbpedia.org/ontology/RailwayTunnel>(?X) .
    INSERT INTO "__triples"(s, p, o) SELECT t0.s, 2, 27856 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27094 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27856);
    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_Tunnel_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Tunnel_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27856;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Tunnel_delta_old" ON "dbrdf_Tunnel_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Tunnel_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/Tunnel$delta_new>(?Y) :- <http://dbpedia.org/ontology/Tunnel$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Tunnel_delta_new"(s) SELECT t1.o FROM "dbrdf_Tunnel_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 = 27856);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1367
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_flyingHours_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_flyingHours_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27857;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_flyingHours_delta_old" ON "dbrdf_flyingHours_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_flyingHours_delta_old" ON "dbrdf_flyingHours_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_flyingHours_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/flyingHours$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/flyingHours$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_flyingHours_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_flyingHours_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 = 27857 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/flyingHours$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/flyingHours$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_flyingHours_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_flyingHours_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 = 27857 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1368
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_shoots_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_shoots_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27858;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_shoots_delta_old" ON "dbrdf_shoots_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_shoots_delta_old" ON "dbrdf_shoots_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_shoots_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/shoots$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/shoots$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_shoots_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_shoots_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 = 27858 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/shoots$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/shoots$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_shoots_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_shoots_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 = 27858 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1369
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstAppearance_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstAppearance_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27859;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstAppearance_delta_old" ON "dbrdf_firstAppearance_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstAppearance_delta_old" ON "dbrdf_firstAppearance_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstAppearance_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/firstAppearance$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/firstAppearance$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_firstAppearance_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_firstAppearance_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 = 27859 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/firstAppearance$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/firstAppearance$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_firstAppearance_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_firstAppearance_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 = 27859 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1370
    ---- DEPENDS ON: 1369, 305, 131, 41, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/FictionalCharacter>(?X) :- <http://dbpedia.org/ontology/lastAppearance>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27860 FROM "__triples" t0 WHERE t0.p = 26522 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27860);
    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_FictionalCharacter_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_FictionalCharacter_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27860;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_FictionalCharacter_delta_old" ON "dbrdf_FictionalCharacter_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_FictionalCharacter_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/FictionalCharacter$delta_new>(?Y) :- <http://dbpedia.org/ontology/FictionalCharacter$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_FictionalCharacter_delta_new"(s) SELECT t1.o FROM "dbrdf_FictionalCharacter_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 = 27860);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1371
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nationalTopographicSystemMapNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nationalTopographicSystemMapNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27861;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nationalTopographicSystemMapNumber_delta_old" ON "dbrdf_nationalTopographicSystemMapNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nationalTopographicSystemMapNumber_delta_old" ON "dbrdf_nationalTopographicSystemMapNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nationalTopographicSystemMapNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/nationalTopographicSystemMapNumber$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/nationalTopographicSystemMapNumber$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_nationalTopographicSystemMapNumber_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_nationalTopographicSystemMapNumber_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 = 27861 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/nationalTopographicSystemMapNumber$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/nationalTopographicSystemMapNumber$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_nationalTopographicSystemMapNumber_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_nationalTopographicSystemMapNumber_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 = 27861 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1372
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_weight_delta_old2"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_weight_delta_old2"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27862;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_weight_delta_old2" ON "dbrdf_weight_delta_old2"(s, o); CREATE INDEX "IDX_1_dbrdf_weight_delta_old2" ON "dbrdf_weight_delta_old2"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_weight_delta_new2"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/AutomobileEngine/weight$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/AutomobileEngine/weight$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_weight_delta_new2"(s, o) SELECT t1.o, t0.o FROM "dbrdf_weight_delta_old2" 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 = 27862 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/AutomobileEngine/weight$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/AutomobileEngine/weight$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_weight_delta_new2"(s, o) SELECT t0.s, t1.o FROM "dbrdf_weight_delta_old2" 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 = 27862 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1373
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_originalMaximumBoatLength_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_originalMaximumBoatLength_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27863;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_originalMaximumBoatLength_delta_old0" ON "dbrdf_originalMaximumBoatLength_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_originalMaximumBoatLength_delta_old0" ON "dbrdf_originalMaximumBoatLength_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_originalMaximumBoatLength_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/originalMaximumBoatLength$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/originalMaximumBoatLength$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_originalMaximumBoatLength_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_originalMaximumBoatLength_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 = 27863 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/originalMaximumBoatLength$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/originalMaximumBoatLength$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_originalMaximumBoatLength_delta_new0"(s, o) SELECT t0.s, t1.o FROM "dbrdf_originalMaximumBoatLength_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 = 27863 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27863, t0.o FROM "dbrdf_originalMaximumBoatLength_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_originalMaximumBoatLength_delta_old0";
        INSERT INTO "dbrdf_originalMaximumBoatLength_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_originalMaximumBoatLength_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_originalMaximumBoatLength_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1374
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_titleDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_titleDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27864;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_titleDate_delta_old" ON "dbrdf_titleDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_titleDate_delta_old" ON "dbrdf_titleDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_titleDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/titleDate$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/titleDate$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_titleDate_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_titleDate_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 = 27864 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/titleDate$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/titleDate$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_titleDate_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_titleDate_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 = 27864 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1375
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mergedIntoParty_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mergedIntoParty_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27865;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mergedIntoParty_delta_old" ON "dbrdf_mergedIntoParty_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mergedIntoParty_delta_old" ON "dbrdf_mergedIntoParty_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mergedIntoParty_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/mergedIntoParty$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/mergedIntoParty$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_mergedIntoParty_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_mergedIntoParty_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 = 27865 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/mergedIntoParty$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/mergedIntoParty$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_mergedIntoParty_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_mergedIntoParty_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 = 27865 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1376
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_governmentPosition_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_governmentPosition_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27866;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_governmentPosition_delta_old" ON "dbrdf_governmentPosition_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_governmentPosition_delta_old" ON "dbrdf_governmentPosition_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_governmentPosition_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/governmentPosition$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/governmentPosition$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_governmentPosition_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_governmentPosition_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 = 27866 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/governmentPosition$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/governmentPosition$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_governmentPosition_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_governmentPosition_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 = 27866 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1377
    ---- 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 = 27867;
    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 = 27867 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 = 27867 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ChemicalElement_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ChemicalElement_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27868;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ChemicalElement_delta_old" ON "dbrdf_ChemicalElement_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ChemicalElement_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/ChemicalElement$delta_new>(?Y) :- <http://dbpedia.org/ontology/ChemicalElement$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_ChemicalElement_delta_new"(s) SELECT t1.o FROM "dbrdf_ChemicalElement_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 = 27868);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1379
    ---- 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 = 27869;
    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 = 27869 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 = 27869 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dateOfBurial_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dateOfBurial_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27870;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dateOfBurial_delta_old" ON "dbrdf_dateOfBurial_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dateOfBurial_delta_old" ON "dbrdf_dateOfBurial_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dateOfBurial_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/dateOfBurial$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/dateOfBurial$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_dateOfBurial_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_dateOfBurial_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 = 27870 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/dateOfBurial$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/dateOfBurial$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_dateOfBurial_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_dateOfBurial_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 = 27870 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1381
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_tonyAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_tonyAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27871;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_tonyAward_delta_old" ON "dbrdf_tonyAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_tonyAward_delta_old" ON "dbrdf_tonyAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_tonyAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/tonyAward$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/tonyAward$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_tonyAward_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_tonyAward_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 = 27871 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/tonyAward$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/tonyAward$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_tonyAward_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_tonyAward_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 = 27871 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1382
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfStaff_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfStaff_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27872;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfStaff_delta_old" ON "dbrdf_numberOfStaff_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfStaff_delta_old" ON "dbrdf_numberOfStaff_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfStaff_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/numberOfStaff$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/numberOfStaff$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_numberOfStaff_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_numberOfStaff_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 = 27872 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/numberOfStaff$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/numberOfStaff$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_numberOfStaff_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_numberOfStaff_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 = 27872 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1383
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfRockets_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfRockets_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27873;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfRockets_delta_old" ON "dbrdf_numberOfRockets_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfRockets_delta_old" ON "dbrdf_numberOfRockets_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfRockets_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/numberOfRockets$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/numberOfRockets$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_numberOfRockets_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_numberOfRockets_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 = 27873 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/numberOfRockets$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/numberOfRockets$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_numberOfRockets_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_numberOfRockets_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 = 27873 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1384
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_riverBranchOf_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_riverBranchOf_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27874;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_riverBranchOf_delta_old" ON "dbrdf_riverBranchOf_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_riverBranchOf_delta_old" ON "dbrdf_riverBranchOf_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_riverBranchOf_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/riverBranchOf$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/riverBranchOf$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_riverBranchOf_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_riverBranchOf_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 = 27874 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/riverBranchOf$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/riverBranchOf$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_riverBranchOf_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_riverBranchOf_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 = 27874 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1385
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rebuildingYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rebuildingYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27875;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rebuildingYear_delta_old" ON "dbrdf_rebuildingYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rebuildingYear_delta_old" ON "dbrdf_rebuildingYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rebuildingYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/rebuildingYear$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/rebuildingYear$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_rebuildingYear_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_rebuildingYear_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 = 27875 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/rebuildingYear$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/rebuildingYear$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_rebuildingYear_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_rebuildingYear_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 = 27875 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1386
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_channel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_channel_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27876;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_channel_delta_old" ON "dbrdf_channel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_channel_delta_old" ON "dbrdf_channel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_channel_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/channel$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/channel$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_channel_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_channel_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 = 27876 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/channel$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/channel$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_channel_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_channel_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 = 27876 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1387
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lowestRegion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lowestRegion_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27877;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lowestRegion_delta_old" ON "dbrdf_lowestRegion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lowestRegion_delta_old" ON "dbrdf_lowestRegion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lowestRegion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/lowestRegion$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/lowestRegion$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_lowestRegion_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_lowestRegion_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 = 27877 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/lowestRegion$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/lowestRegion$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_lowestRegion_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_lowestRegion_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 = 27877 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1388
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_managementPlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_managementPlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27878;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_managementPlace_delta_old" ON "dbrdf_managementPlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_managementPlace_delta_old" ON "dbrdf_managementPlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_managementPlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/managementPlace$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/managementPlace$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_managementPlace_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_managementPlace_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 = 27878 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/managementPlace$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/managementPlace$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_managementPlace_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_managementPlace_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 = 27878 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1389
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_voltageOfElectrification_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_voltageOfElectrification_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27879;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_voltageOfElectrification_delta_old" ON "dbrdf_voltageOfElectrification_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_voltageOfElectrification_delta_old" ON "dbrdf_voltageOfElectrification_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_voltageOfElectrification_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/voltageOfElectrification$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/voltageOfElectrification$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_voltageOfElectrification_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_voltageOfElectrification_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 = 27879 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/voltageOfElectrification$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/voltageOfElectrification$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_voltageOfElectrification_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_voltageOfElectrification_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 = 27879 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1390
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_boilingPoint_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_boilingPoint_delta_old1"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27880;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_boilingPoint_delta_old1" ON "dbrdf_boilingPoint_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_boilingPoint_delta_old1" ON "dbrdf_boilingPoint_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_boilingPoint_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/Drug/boilingPoint$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Drug/boilingPoint$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_boilingPoint_delta_new1"(s, o) SELECT t1.o, t0.o FROM "dbrdf_boilingPoint_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 = 27880 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/Drug/boilingPoint$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/Drug/boilingPoint$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_boilingPoint_delta_new1"(s, o) SELECT t0.s, t1.o FROM "dbrdf_boilingPoint_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 = 27880 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27880, t0.o FROM "dbrdf_boilingPoint_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_boilingPoint_delta_old1";
        INSERT INTO "dbrdf_boilingPoint_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_boilingPoint_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_boilingPoint_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1391
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_draftPick_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_draftPick_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27881;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_draftPick_delta_old" ON "dbrdf_draftPick_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_draftPick_delta_old" ON "dbrdf_draftPick_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_draftPick_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/draftPick$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/draftPick$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_draftPick_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_draftPick_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 = 27881 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/draftPick$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/draftPick$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_draftPick_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_draftPick_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 = 27881 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1392
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_period_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_period_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27882;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_period_delta_old" ON "dbrdf_period_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_period_delta_old" ON "dbrdf_period_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_period_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/period$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/period$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_period_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_period_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 = 27882 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/period$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/period$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_period_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_period_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 = 27882 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1393
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_officialLanguage_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_officialLanguage_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27883;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_officialLanguage_delta_old" ON "dbrdf_officialLanguage_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_officialLanguage_delta_old" ON "dbrdf_officialLanguage_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_officialLanguage_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/officialLanguage$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/officialLanguage$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_officialLanguage_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_officialLanguage_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 = 27883 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/officialLanguage$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/officialLanguage$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_officialLanguage_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_officialLanguage_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 = 27883 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1394
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_keyPerson_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_keyPerson_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27884;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_keyPerson_delta_old" ON "dbrdf_keyPerson_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_keyPerson_delta_old" ON "dbrdf_keyPerson_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_keyPerson_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/keyPerson$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/keyPerson$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_keyPerson_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_keyPerson_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 = 27884 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/keyPerson$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/keyPerson$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_keyPerson_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_keyPerson_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 = 27884 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1395
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_person_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_person_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27885;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_person_delta_old" ON "dbrdf_person_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_person_delta_old" ON "dbrdf_person_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_person_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/person$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/person$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_person_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_person_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 = 27885 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/person$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/person$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_person_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_person_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 = 27885 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1396
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_executiveProducer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_executiveProducer_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27886;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_executiveProducer_delta_old" ON "dbrdf_executiveProducer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_executiveProducer_delta_old" ON "dbrdf_executiveProducer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_executiveProducer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/executiveProducer$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/executiveProducer$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_executiveProducer_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_executiveProducer_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 = 27886 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/executiveProducer$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/executiveProducer$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_executiveProducer_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_executiveProducer_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 = 27886 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1397
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cargoGas_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cargoGas_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27887;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cargoGas_delta_old" ON "dbrdf_cargoGas_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_cargoGas_delta_old" ON "dbrdf_cargoGas_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cargoGas_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/cargoGas$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/cargoGas$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_cargoGas_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_cargoGas_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 = 27887 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/cargoGas$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/cargoGas$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_cargoGas_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_cargoGas_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 = 27887 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1398
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_unitaryAuthority_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_unitaryAuthority_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27888;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_unitaryAuthority_delta_old" ON "dbrdf_unitaryAuthority_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_unitaryAuthority_delta_old" ON "dbrdf_unitaryAuthority_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_unitaryAuthority_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/unitaryAuthority$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/unitaryAuthority$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_unitaryAuthority_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_unitaryAuthority_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 = 27888 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/unitaryAuthority$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/unitaryAuthority$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_unitaryAuthority_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_unitaryAuthority_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 = 27888 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1399
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_albedo_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_albedo_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27889;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_albedo_delta_old" ON "dbrdf_albedo_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_albedo_delta_old" ON "dbrdf_albedo_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_albedo_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/albedo$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/albedo$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_albedo_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_albedo_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 = 27889 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/albedo$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/albedo$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_albedo_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_albedo_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 = 27889 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1400
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_identificationSymbol_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_identificationSymbol_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27890;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_identificationSymbol_delta_old" ON "dbrdf_identificationSymbol_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_identificationSymbol_delta_old" ON "dbrdf_identificationSymbol_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_identificationSymbol_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/identificationSymbol$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/identificationSymbol$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_identificationSymbol_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_identificationSymbol_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 = 27890 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/identificationSymbol$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/identificationSymbol$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_identificationSymbol_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_identificationSymbol_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 = 27890 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1401
    ---- 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 = 27891;
    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 = 27891 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 = 27891 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_designCompany_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_designCompany_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27892;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_designCompany_delta_old" ON "dbrdf_designCompany_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_designCompany_delta_old" ON "dbrdf_designCompany_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_designCompany_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/designCompany$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/designCompany$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_designCompany_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_designCompany_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 = 27892 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/designCompany$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/designCompany$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_designCompany_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_designCompany_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 = 27892 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1403
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_whaDraftTeam_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_whaDraftTeam_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27893;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_whaDraftTeam_delta_old" ON "dbrdf_whaDraftTeam_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_whaDraftTeam_delta_old" ON "dbrdf_whaDraftTeam_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_whaDraftTeam_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/whaDraftTeam$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/whaDraftTeam$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_whaDraftTeam_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_whaDraftTeam_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 = 27893 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/whaDraftTeam$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/whaDraftTeam$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_whaDraftTeam_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_whaDraftTeam_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 = 27893 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1404
    ---- DEPENDS ON: 1403, 980, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- [Rule] <http://dbpedia.org/ontology/HockeyTeam>(?X1) :- <http://dbpedia.org/ontology/prospectTeam>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.o, 2, 27894 FROM "__triples" t0 WHERE t0.p = 27467 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.o AND ex.p = 2 AND ex.o = 27894);
    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_HockeyTeam_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_HockeyTeam_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27894;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_HockeyTeam_delta_old" ON "dbrdf_HockeyTeam_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_HockeyTeam_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/HockeyTeam$delta_new>(?Y) :- <http://dbpedia.org/ontology/HockeyTeam$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_HockeyTeam_delta_new"(s) SELECT t1.o FROM "dbrdf_HockeyTeam_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 = 27894);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1405
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_precursor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_precursor_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27895;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_precursor_delta_old" ON "dbrdf_precursor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_precursor_delta_old" ON "dbrdf_precursor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_precursor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/precursor$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/precursor$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_precursor_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_precursor_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 = 27895 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/precursor$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/precursor$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_precursor_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_precursor_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 = 27895 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1406
    ---- DEPENDS ON: 1405, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Embryology>(?X1) :- <http://dbpedia.org/ontology/precursor>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.o, 2, 27896 FROM "__triples" t0 WHERE t0.p = 27895 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.o AND ex.p = 2 AND ex.o = 27896);
    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_Embryology_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Embryology_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27896;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Embryology_delta_old" ON "dbrdf_Embryology_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Embryology_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/Embryology$delta_new>(?Y) :- <http://dbpedia.org/ontology/Embryology$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Embryology_delta_new"(s) SELECT t1.o FROM "dbrdf_Embryology_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 = 27896);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1407
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_manxName_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_manxName_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27897;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_manxName_delta_old" ON "dbrdf_manxName_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_manxName_delta_old" ON "dbrdf_manxName_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_manxName_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/manxName$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/manxName$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_manxName_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_manxName_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 = 27897 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/manxName$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/manxName$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_manxName_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_manxName_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 = 27897 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1408
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_daylightSavingTimeZone_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_daylightSavingTimeZone_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27898;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_daylightSavingTimeZone_delta_old" ON "dbrdf_daylightSavingTimeZone_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_daylightSavingTimeZone_delta_old" ON "dbrdf_daylightSavingTimeZone_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_daylightSavingTimeZone_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/daylightSavingTimeZone$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/daylightSavingTimeZone$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_daylightSavingTimeZone_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_daylightSavingTimeZone_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 = 27898 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/daylightSavingTimeZone$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/daylightSavingTimeZone$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_daylightSavingTimeZone_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_daylightSavingTimeZone_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 = 27898 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1409
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dubber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dubber_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27899;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dubber_delta_old" ON "dbrdf_dubber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dubber_delta_old" ON "dbrdf_dubber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dubber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/dubber$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/dubber$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_dubber_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_dubber_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 = 27899 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/dubber$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/dubber$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_dubber_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_dubber_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 = 27899 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1410
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lowerAge_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lowerAge_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27900;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lowerAge_delta_old" ON "dbrdf_lowerAge_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lowerAge_delta_old" ON "dbrdf_lowerAge_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lowerAge_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/lowerAge$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/lowerAge$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_lowerAge_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_lowerAge_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 = 27900 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/lowerAge$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/lowerAge$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_lowerAge_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_lowerAge_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 = 27900 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1411
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_launchPad_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_launchPad_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27901;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_launchPad_delta_old" ON "dbrdf_launchPad_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_launchPad_delta_old" ON "dbrdf_launchPad_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_launchPad_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/launchPad$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/launchPad$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_launchPad_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_launchPad_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 = 27901 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/launchPad$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/launchPad$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_launchPad_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_launchPad_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 = 27901 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1412
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_director_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_director_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27902;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_director_delta_old" ON "dbrdf_director_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_director_delta_old" ON "dbrdf_director_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_director_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/director$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/director$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_director_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_director_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 = 27902 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/director$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/director$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_director_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_director_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 = 27902 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1413
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumElevation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_maximumElevation_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27903;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_maximumElevation_delta_old" ON "dbrdf_maximumElevation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_maximumElevation_delta_old" ON "dbrdf_maximumElevation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumElevation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/maximumElevation$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/maximumElevation$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_maximumElevation_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_maximumElevation_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 = 27903 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/maximumElevation$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/maximumElevation$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_maximumElevation_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_maximumElevation_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 = 27903 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1414
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_associateEditor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_associateEditor_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27904;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_associateEditor_delta_old" ON "dbrdf_associateEditor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_associateEditor_delta_old" ON "dbrdf_associateEditor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_associateEditor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/associateEditor$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/associateEditor$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_associateEditor_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_associateEditor_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 = 27904 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/associateEditor$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/associateEditor$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_associateEditor_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_associateEditor_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 = 27904 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1415
    ---- DEPENDS ON: 1414, 1203, 717, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Newspaper>(?X1) :- <http://dbpedia.org/ontology/sisterNewspaper>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.o, 2, 27905 FROM "__triples" t0 WHERE t0.p = 27692 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.o AND ex.p = 2 AND ex.o = 27905);
    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_Newspaper_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Newspaper_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27905;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Newspaper_delta_old" ON "dbrdf_Newspaper_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Newspaper_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/Newspaper$delta_new>(?Y) :- <http://dbpedia.org/ontology/Newspaper$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Newspaper_delta_new"(s) SELECT t1.o FROM "dbrdf_Newspaper_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 = 27905);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1416
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_currentRank_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_currentRank_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27906;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_currentRank_delta_old" ON "dbrdf_currentRank_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_currentRank_delta_old" ON "dbrdf_currentRank_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_currentRank_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/currentRank$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/currentRank$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_currentRank_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_currentRank_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 = 27906 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/currentRank$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/currentRank$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_currentRank_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_currentRank_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 = 27906 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1417
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_LacrosseLeague_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_LacrosseLeague_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27907;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_LacrosseLeague_delta_old" ON "dbrdf_LacrosseLeague_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_LacrosseLeague_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/LacrosseLeague$delta_new>(?Y) :- <http://dbpedia.org/ontology/LacrosseLeague$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_LacrosseLeague_delta_new"(s) SELECT t1.o FROM "dbrdf_LacrosseLeague_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 = 27907);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1418
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_painter_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_painter_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27908;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_painter_delta_old" ON "dbrdf_painter_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_painter_delta_old" ON "dbrdf_painter_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_painter_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/painter$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/painter$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_painter_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_painter_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 = 27908 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/painter$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/painter$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_painter_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_painter_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 = 27908 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1419
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_countryOrigin_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_countryOrigin_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27909;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_countryOrigin_delta_old" ON "dbrdf_countryOrigin_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_countryOrigin_delta_old" ON "dbrdf_countryOrigin_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_countryOrigin_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/countryOrigin$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/countryOrigin$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_countryOrigin_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_countryOrigin_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 = 27909 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/countryOrigin$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/countryOrigin$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_countryOrigin_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_countryOrigin_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 = 27909 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1420
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_BaseballLeague_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_BaseballLeague_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27910;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_BaseballLeague_delta_old" ON "dbrdf_BaseballLeague_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_BaseballLeague_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/BaseballLeague$delta_new>(?Y) :- <http://dbpedia.org/ontology/BaseballLeague$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_BaseballLeague_delta_new"(s) SELECT t1.o FROM "dbrdf_BaseballLeague_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 = 27910);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1421
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_significantProject_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_significantProject_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27911;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_significantProject_delta_old" ON "dbrdf_significantProject_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_significantProject_delta_old" ON "dbrdf_significantProject_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_significantProject_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/significantProject$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/significantProject$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_significantProject_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_significantProject_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 = 27911 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/significantProject$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/significantProject$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_significantProject_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_significantProject_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 = 27911 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1422
    ---- DEPENDS ON: 1421, 335, 48, 11, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Architect>(?X) :- <http://dbpedia.org/ontology/significantDesign>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27912 FROM "__triples" t0 WHERE t0.p = 26492 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27912);
    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_Architect_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Architect_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27912;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Architect_delta_old" ON "dbrdf_Architect_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Architect_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/Architect$delta_new>(?Y) :- <http://dbpedia.org/ontology/Architect$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Architect_delta_new"(s) SELECT t1.o FROM "dbrdf_Architect_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 = 27912);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1423
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsSupergroup_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_alpsSupergroup_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27913;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_alpsSupergroup_delta_old" ON "dbrdf_alpsSupergroup_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_alpsSupergroup_delta_old" ON "dbrdf_alpsSupergroup_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsSupergroup_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/alpsSupergroup$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/alpsSupergroup$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_alpsSupergroup_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_alpsSupergroup_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 = 27913 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/alpsSupergroup$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/alpsSupergroup$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_alpsSupergroup_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_alpsSupergroup_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 = 27913 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1424
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstDriverCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstDriverCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27914;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstDriverCountry_delta_old" ON "dbrdf_firstDriverCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstDriverCountry_delta_old" ON "dbrdf_firstDriverCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstDriverCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/firstDriverCountry$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/firstDriverCountry$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_firstDriverCountry_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_firstDriverCountry_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 = 27914 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/firstDriverCountry$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/firstDriverCountry$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_firstDriverCountry_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_firstDriverCountry_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 = 27914 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1425
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Mineral_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Mineral_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27915;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Mineral_delta_old" ON "dbrdf_Mineral_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Mineral_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/Mineral$delta_new>(?Y) :- <http://dbpedia.org/ontology/Mineral$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Mineral_delta_new"(s) SELECT t1.o FROM "dbrdf_Mineral_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 = 27915);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1426
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lifeExpectancy_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lifeExpectancy_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27916;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lifeExpectancy_delta_old" ON "dbrdf_lifeExpectancy_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lifeExpectancy_delta_old" ON "dbrdf_lifeExpectancy_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lifeExpectancy_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/lifeExpectancy$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/lifeExpectancy$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_lifeExpectancy_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_lifeExpectancy_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 = 27916 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/lifeExpectancy$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/lifeExpectancy$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_lifeExpectancy_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_lifeExpectancy_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 = 27916 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1427
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_material_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_material_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27917;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_material_delta_old" ON "dbrdf_material_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_material_delta_old" ON "dbrdf_material_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_material_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/material$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/material$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_material_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_material_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 = 27917 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/material$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/material$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_material_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_material_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 = 27917 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1428
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_functionStartYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_functionStartYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27918;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_functionStartYear_delta_old" ON "dbrdf_functionStartYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_functionStartYear_delta_old" ON "dbrdf_functionStartYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_functionStartYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/functionStartYear$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/functionStartYear$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_functionStartYear_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_functionStartYear_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 = 27918 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/functionStartYear$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/functionStartYear$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_functionStartYear_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_functionStartYear_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 = 27918 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1429
    ---- DEPENDS ON: 1271, 1063, 942, 854, 672, 558, 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, 27920 FROM "__triples" t0 WHERE t0.p = 27760 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27920);
    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, 27920 FROM "__triples" t0 WHERE t0.p = 27550 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27920);
    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, 27920 FROM "__triples" t0 WHERE t0.p = 27156 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27920);
    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, 27920 FROM "__triples" t0 WHERE t0.p = 27041 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27920);
    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, 27920 FROM "__triples" t0 WHERE t0.p = 27341 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27920);
    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, 27920 FROM "__triples" t0 WHERE t0.p = 27429 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27920);
    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 = 27919;
    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 = 27920;
    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 = 27919);


        -- <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 = 27919);


        -- <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 = 27920);


        -- <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 = 27920);


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_notableFeatures_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_notableFeatures_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27921;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_notableFeatures_delta_old" ON "dbrdf_notableFeatures_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_notableFeatures_delta_old" ON "dbrdf_notableFeatures_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_notableFeatures_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/notableFeatures$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/notableFeatures$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_notableFeatures_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_notableFeatures_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 = 27921 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/notableFeatures$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/notableFeatures$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_notableFeatures_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_notableFeatures_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 = 27921 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1431
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sportSpecialty_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sportSpecialty_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27922;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sportSpecialty_delta_old" ON "dbrdf_sportSpecialty_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sportSpecialty_delta_old" ON "dbrdf_sportSpecialty_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sportSpecialty_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/sportSpecialty$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/sportSpecialty$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_sportSpecialty_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_sportSpecialty_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 = 27922 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/sportSpecialty$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/sportSpecialty$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_sportSpecialty_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_sportSpecialty_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 = 27922 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1432
    ---- 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 = 27923;
    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 = 27923 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 = 27923 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_illustrator_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_illustrator_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27924;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_illustrator_delta_old" ON "dbrdf_illustrator_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_illustrator_delta_old" ON "dbrdf_illustrator_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_illustrator_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/illustrator$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/illustrator$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_illustrator_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_illustrator_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 = 27924 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/illustrator$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/illustrator$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_illustrator_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_illustrator_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 = 27924 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1434
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cesarAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cesarAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27925;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cesarAward_delta_old" ON "dbrdf_cesarAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_cesarAward_delta_old" ON "dbrdf_cesarAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cesarAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/cesarAward$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/cesarAward$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_cesarAward_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_cesarAward_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 = 27925 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/cesarAward$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/cesarAward$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_cesarAward_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_cesarAward_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 = 27925 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1435
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_maidenVoyage_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_maidenVoyage_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27926;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_maidenVoyage_delta_old" ON "dbrdf_maidenVoyage_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_maidenVoyage_delta_old" ON "dbrdf_maidenVoyage_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_maidenVoyage_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/maidenVoyage$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/maidenVoyage$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_maidenVoyage_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_maidenVoyage_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 = 27926 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/maidenVoyage$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/maidenVoyage$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_maidenVoyage_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_maidenVoyage_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 = 27926 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1436
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_emedicineSubject_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_emedicineSubject_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27927;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_emedicineSubject_delta_old" ON "dbrdf_emedicineSubject_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_emedicineSubject_delta_old" ON "dbrdf_emedicineSubject_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_emedicineSubject_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/emedicineSubject$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/emedicineSubject$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_emedicineSubject_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_emedicineSubject_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 = 27927 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/emedicineSubject$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/emedicineSubject$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_emedicineSubject_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_emedicineSubject_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 = 27927 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1437
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ceeb_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ceeb_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27928;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ceeb_delta_old" ON "dbrdf_ceeb_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ceeb_delta_old" ON "dbrdf_ceeb_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ceeb_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/ceeb$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/ceeb$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_ceeb_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_ceeb_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 = 27928 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/ceeb$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/ceeb$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_ceeb_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_ceeb_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 = 27928 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1438
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Insect_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Insect_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27929;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Insect_delta_old" ON "dbrdf_Insect_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Insect_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/Insect$delta_new>(?Y) :- <http://dbpedia.org/ontology/Insect$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Insect_delta_new"(s) SELECT t1.o FROM "dbrdf_Insect_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 = 27929);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1439
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_recentWinner_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_recentWinner_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27930;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_recentWinner_delta_old" ON "dbrdf_recentWinner_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_recentWinner_delta_old" ON "dbrdf_recentWinner_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_recentWinner_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/recentWinner$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/recentWinner$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_recentWinner_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_recentWinner_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 = 27930 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/recentWinner$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/recentWinner$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_recentWinner_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_recentWinner_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 = 27930 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1440
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_whaDraft_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_whaDraft_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27931;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_whaDraft_delta_old" ON "dbrdf_whaDraft_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_whaDraft_delta_old" ON "dbrdf_whaDraft_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_whaDraft_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/whaDraft$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/whaDraft$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_whaDraft_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_whaDraft_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 = 27931 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/whaDraft$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/whaDraft$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_whaDraft_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_whaDraft_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 = 27931 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1441
    ---- DEPENDS ON: 1440, 1403, 1368, 980, 709, 627, 393, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/IceHockeyPlayer>(?X) :- <http://dbpedia.org/ontology/hallOfFame>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27932 FROM "__triples" t0 WHERE t0.p = 26876 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27932);
    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_IceHockeyPlayer_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_IceHockeyPlayer_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27932;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_IceHockeyPlayer_delta_old" ON "dbrdf_IceHockeyPlayer_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_IceHockeyPlayer_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/IceHockeyPlayer$delta_new>(?Y) :- <http://dbpedia.org/ontology/IceHockeyPlayer$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_IceHockeyPlayer_delta_new"(s) SELECT t1.o FROM "dbrdf_IceHockeyPlayer_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 = 27932);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1442
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_philosophicalSchool_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_philosophicalSchool_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27933;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_philosophicalSchool_delta_old" ON "dbrdf_philosophicalSchool_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_philosophicalSchool_delta_old" ON "dbrdf_philosophicalSchool_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_philosophicalSchool_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/philosophicalSchool$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/philosophicalSchool$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_philosophicalSchool_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_philosophicalSchool_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 = 27933 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/philosophicalSchool$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/philosophicalSchool$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_philosophicalSchool_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_philosophicalSchool_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 = 27933 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1443
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfUndergraduateStudents_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfUndergraduateStudents_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27934;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfUndergraduateStudents_delta_old" ON "dbrdf_numberOfUndergraduateStudents_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfUndergraduateStudents_delta_old" ON "dbrdf_numberOfUndergraduateStudents_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfUndergraduateStudents_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/numberOfUndergraduateStudents$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/numberOfUndergraduateStudents$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_numberOfUndergraduateStudents_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_numberOfUndergraduateStudents_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 = 27934 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/numberOfUndergraduateStudents$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/numberOfUndergraduateStudents$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_numberOfUndergraduateStudents_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_numberOfUndergraduateStudents_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 = 27934 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1444
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_tenant_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_tenant_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27935;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_tenant_delta_old" ON "dbrdf_tenant_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_tenant_delta_old" ON "dbrdf_tenant_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_tenant_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/tenant$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/tenant$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_tenant_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_tenant_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 = 27935 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/tenant$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/tenant$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_tenant_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_tenant_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 = 27935 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1445
    ---- 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 = 27936;
    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 = 27936 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 = 27936 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_jointCommunity_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_jointCommunity_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27937;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_jointCommunity_delta_old" ON "dbrdf_jointCommunity_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_jointCommunity_delta_old" ON "dbrdf_jointCommunity_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_jointCommunity_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/jointCommunity$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/jointCommunity$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_jointCommunity_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_jointCommunity_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 = 27937 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/jointCommunity$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/jointCommunity$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_jointCommunity_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_jointCommunity_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 = 27937 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1447
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftAttack_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftAttack_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27938;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftAttack_delta_old" ON "dbrdf_aircraftAttack_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftAttack_delta_old" ON "dbrdf_aircraftAttack_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftAttack_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/aircraftAttack$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/aircraftAttack$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_aircraftAttack_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_aircraftAttack_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 = 27938 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/aircraftAttack$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/aircraftAttack$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_aircraftAttack_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_aircraftAttack_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 = 27938 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1448
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_associateStar_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_associateStar_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27939;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_associateStar_delta_old" ON "dbrdf_associateStar_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_associateStar_delta_old" ON "dbrdf_associateStar_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_associateStar_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/associateStar$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/associateStar$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_associateStar_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_associateStar_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 = 27939 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/associateStar$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/associateStar$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_associateStar_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_associateStar_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 = 27939 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1449
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_parkingInformation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_parkingInformation_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27940;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_parkingInformation_delta_old" ON "dbrdf_parkingInformation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_parkingInformation_delta_old" ON "dbrdf_parkingInformation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_parkingInformation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/parkingInformation$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/parkingInformation$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_parkingInformation_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_parkingInformation_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 = 27940 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/parkingInformation$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/parkingInformation$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_parkingInformation_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_parkingInformation_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 = 27940 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1450
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_hairColor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_hairColor_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27941;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_hairColor_delta_old" ON "dbrdf_hairColor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_hairColor_delta_old" ON "dbrdf_hairColor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_hairColor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/hairColor$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/hairColor$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_hairColor_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_hairColor_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 = 27941 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/hairColor$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/hairColor$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_hairColor_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_hairColor_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 = 27941 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1451
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_introduced_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_introduced_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27942;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_introduced_delta_old" ON "dbrdf_introduced_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_introduced_delta_old" ON "dbrdf_introduced_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_introduced_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/introduced$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/introduced$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_introduced_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_introduced_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 = 27942 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/introduced$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/introduced$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_introduced_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_introduced_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 = 27942 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1452
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Chancellor_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Chancellor_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27943;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Chancellor_delta_old" ON "dbrdf_Chancellor_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Chancellor_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/Chancellor$delta_new>(?Y) :- <http://dbpedia.org/ontology/Chancellor$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Chancellor_delta_new"(s) SELECT t1.o FROM "dbrdf_Chancellor_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 = 27943);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1453
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_missionDuration_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_missionDuration_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27944;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_missionDuration_delta_old0" ON "dbrdf_missionDuration_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_missionDuration_delta_old0" ON "dbrdf_missionDuration_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_missionDuration_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/missionDuration$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/SpaceMission/missionDuration$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_missionDuration_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_missionDuration_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 = 27944 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/SpaceMission/missionDuration$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/SpaceMission/missionDuration$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_missionDuration_delta_new0"(s, o) SELECT t0.s, t1.o FROM "dbrdf_missionDuration_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 = 27944 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27944, t0.o FROM "dbrdf_missionDuration_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_missionDuration_delta_old0";
        INSERT INTO "dbrdf_missionDuration_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_missionDuration_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_missionDuration_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1454
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cargoGas_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cargoGas_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27945;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cargoGas_delta_old0" ON "dbrdf_cargoGas_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_cargoGas_delta_old0" ON "dbrdf_cargoGas_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cargoGas_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Spacecraft/cargoGas$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Spacecraft/cargoGas$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_cargoGas_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_cargoGas_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 = 27945 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/Spacecraft/cargoGas$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/Spacecraft/cargoGas$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_cargoGas_delta_new0"(s, o) SELECT t0.s, t1.o FROM "dbrdf_cargoGas_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 = 27945 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27945, t0.o FROM "dbrdf_cargoGas_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_cargoGas_delta_old0";
        INSERT INTO "dbrdf_cargoGas_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cargoGas_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_cargoGas_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1455
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_alliance_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_alliance_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27946;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_alliance_delta_old" ON "dbrdf_alliance_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_alliance_delta_old" ON "dbrdf_alliance_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_alliance_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/alliance$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/alliance$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_alliance_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_alliance_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 = 27946 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/alliance$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/alliance$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_alliance_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_alliance_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 = 27946 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1456
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_gridReference_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_gridReference_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27947;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_gridReference_delta_old" ON "dbrdf_gridReference_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_gridReference_delta_old" ON "dbrdf_gridReference_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_gridReference_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/gridReference$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/gridReference$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_gridReference_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_gridReference_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 = 27947 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/gridReference$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/gridReference$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_gridReference_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_gridReference_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 = 27947 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1457
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_youthClub_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_youthClub_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27948;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_youthClub_delta_old" ON "dbrdf_youthClub_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_youthClub_delta_old" ON "dbrdf_youthClub_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_youthClub_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/youthClub$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/youthClub$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_youthClub_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_youthClub_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 = 27948 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/youthClub$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/youthClub$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_youthClub_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_youthClub_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 = 27948 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1458
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_SoccerClubSeason_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SoccerClubSeason_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27949;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SoccerClubSeason_delta_old" ON "dbrdf_SoccerClubSeason_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SoccerClubSeason_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/SoccerClubSeason$delta_new>(?Y) :- <http://dbpedia.org/ontology/SoccerClubSeason$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_SoccerClubSeason_delta_new"(s) SELECT t1.o FROM "dbrdf_SoccerClubSeason_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 = 27949);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1459
    ---- DEPENDS ON: 1458, 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, 27950 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27949 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27950);
    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 = 27950;
    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 = 27950);


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dockedTime_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dockedTime_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27951;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dockedTime_delta_old0" ON "dbrdf_dockedTime_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_dockedTime_delta_old0" ON "dbrdf_dockedTime_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dockedTime_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/dockedTime$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/dockedTime$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_dockedTime_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_dockedTime_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 = 27951 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/dockedTime$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/dockedTime$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_dockedTime_delta_new0"(s, o) SELECT t0.s, t1.o FROM "dbrdf_dockedTime_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 = 27951 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27951, t0.o FROM "dbrdf_dockedTime_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_dockedTime_delta_old0";
        INSERT INTO "dbrdf_dockedTime_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_dockedTime_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_dockedTime_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1461
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_routeNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_routeNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27952;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_routeNumber_delta_old" ON "dbrdf_routeNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_routeNumber_delta_old" ON "dbrdf_routeNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_routeNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/routeNumber$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/routeNumber$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_routeNumber_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_routeNumber_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 = 27952 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/routeNumber$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/routeNumber$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_routeNumber_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_routeNumber_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 = 27952 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1462
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_fastestDriverCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_fastestDriverCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27953;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_fastestDriverCountry_delta_old" ON "dbrdf_fastestDriverCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_fastestDriverCountry_delta_old" ON "dbrdf_fastestDriverCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_fastestDriverCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/fastestDriverCountry$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/fastestDriverCountry$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_fastestDriverCountry_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_fastestDriverCountry_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 = 27953 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/fastestDriverCountry$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/fastestDriverCountry$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_fastestDriverCountry_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_fastestDriverCountry_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 = 27953 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1463
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_broadcastArea_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_broadcastArea_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27954;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_broadcastArea_delta_old" ON "dbrdf_broadcastArea_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_broadcastArea_delta_old" ON "dbrdf_broadcastArea_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_broadcastArea_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/broadcastArea$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/broadcastArea$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_broadcastArea_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_broadcastArea_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 = 27954 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/broadcastArea$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/broadcastArea$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_broadcastArea_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_broadcastArea_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 = 27954 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1464
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_centuryBreaks_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_centuryBreaks_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27955;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_centuryBreaks_delta_old" ON "dbrdf_centuryBreaks_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_centuryBreaks_delta_old" ON "dbrdf_centuryBreaks_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_centuryBreaks_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/centuryBreaks$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/centuryBreaks$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_centuryBreaks_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_centuryBreaks_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 = 27955 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/centuryBreaks$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/centuryBreaks$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_centuryBreaks_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_centuryBreaks_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 = 27955 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1465
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_surfaceArea_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_surfaceArea_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27956;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_surfaceArea_delta_old0" ON "dbrdf_surfaceArea_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_surfaceArea_delta_old0" ON "dbrdf_surfaceArea_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_surfaceArea_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/surfaceArea$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/surfaceArea$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_surfaceArea_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_surfaceArea_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 = 27956 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/surfaceArea$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/surfaceArea$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_surfaceArea_delta_new0"(s, o) SELECT t0.s, t1.o FROM "dbrdf_surfaceArea_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 = 27956 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27956, t0.o FROM "dbrdf_surfaceArea_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_surfaceArea_delta_old0";
        INSERT INTO "dbrdf_surfaceArea_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_surfaceArea_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_surfaceArea_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1466
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_startPoint_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_startPoint_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27957;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_startPoint_delta_old" ON "dbrdf_startPoint_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_startPoint_delta_old" ON "dbrdf_startPoint_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_startPoint_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/startPoint$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/startPoint$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_startPoint_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_startPoint_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 = 27957 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/startPoint$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/startPoint$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_startPoint_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_startPoint_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 = 27957 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1467
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_eurobabeIndexId_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_eurobabeIndexId_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27958;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_eurobabeIndexId_delta_old" ON "dbrdf_eurobabeIndexId_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_eurobabeIndexId_delta_old" ON "dbrdf_eurobabeIndexId_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_eurobabeIndexId_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/eurobabeIndexId$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/eurobabeIndexId$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_eurobabeIndexId_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_eurobabeIndexId_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 = 27958 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/eurobabeIndexId$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/eurobabeIndexId$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
