    CREATE LOCAL TEMPORARY TABLE "dbrdf_bicycleInformation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_bicycleInformation_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27126;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_bicycleInformation_delta_old" ON "dbrdf_bicycleInformation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_bicycleInformation_delta_old" ON "dbrdf_bicycleInformation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_bicycleInformation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 645
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_spurOf_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_spurOf_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27127;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_spurOf_delta_old" ON "dbrdf_spurOf_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_spurOf_delta_old" ON "dbrdf_spurOf_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_spurOf_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 646
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 647
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_originalMaximumBoatBeam_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_originalMaximumBoatBeam_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27129;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_originalMaximumBoatBeam_delta_old" ON "dbrdf_originalMaximumBoatBeam_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_originalMaximumBoatBeam_delta_old" ON "dbrdf_originalMaximumBoatBeam_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_originalMaximumBoatBeam_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 648
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_garrison_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_garrison_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27130;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_garrison_delta_old" ON "dbrdf_garrison_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_garrison_delta_old" ON "dbrdf_garrison_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_garrison_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 649
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_draftYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_draftYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27131;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_draftYear_delta_old" ON "dbrdf_draftYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_draftYear_delta_old" ON "dbrdf_draftYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_draftYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 650
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_certificationDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_certificationDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27132;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_certificationDate_delta_old" ON "dbrdf_certificationDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_certificationDate_delta_old" ON "dbrdf_certificationDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_certificationDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 651
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfVehicles_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfVehicles_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27133;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfVehicles_delta_old" ON "dbrdf_numberOfVehicles_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfVehicles_delta_old" ON "dbrdf_numberOfVehicles_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfVehicles_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 652
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_genus_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_genus_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27134;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_genus_delta_old" ON "dbrdf_genus_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_genus_delta_old" ON "dbrdf_genus_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_genus_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 653
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_architect_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_architect_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27135;
    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, o); CREATE INDEX "IDX_1_dbrdf_architect_delta_old" ON "dbrdf_architect_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_architect_delta_new"(s integer, o 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,?X1) :- <http://dbpedia.org/ontology/architect$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_architect_delta_new"(s, o) SELECT t1.o, t0.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 = 27135 AND ex.o = t0.o);


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 654
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_formationDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_formationDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27136;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_formationDate_delta_old" ON "dbrdf_formationDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_formationDate_delta_old" ON "dbrdf_formationDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_formationDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 655
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ethnicGroupsInYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ethnicGroupsInYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27137;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ethnicGroupsInYear_delta_old" ON "dbrdf_ethnicGroupsInYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ethnicGroupsInYear_delta_old" ON "dbrdf_ethnicGroupsInYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ethnicGroupsInYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 656
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstLaunch_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstLaunch_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27138;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstLaunch_delta_old" ON "dbrdf_firstLaunch_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstLaunch_delta_old" ON "dbrdf_firstLaunch_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstLaunch_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 657
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_originalMaximumBoatLength_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_originalMaximumBoatLength_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27139;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_originalMaximumBoatLength_delta_old" ON "dbrdf_originalMaximumBoatLength_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_originalMaximumBoatLength_delta_old" ON "dbrdf_originalMaximumBoatLength_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_originalMaximumBoatLength_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27139, t0.o FROM "dbrdf_originalMaximumBoatLength_delta_new" 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_old";
        INSERT INTO "dbrdf_originalMaximumBoatLength_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_originalMaximumBoatLength_delta_new" t0;
        TRUNCATE TABLE "dbrdf_originalMaximumBoatLength_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 658
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_majorVolcano_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_majorVolcano_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27140;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_majorVolcano_delta_old" ON "dbrdf_majorVolcano_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_majorVolcano_delta_old" ON "dbrdf_majorVolcano_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_majorVolcano_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 659
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sisterNewspaper_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sisterNewspaper_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27141;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sisterNewspaper_delta_old" ON "dbrdf_sisterNewspaper_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sisterNewspaper_delta_old" ON "dbrdf_sisterNewspaper_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sisterNewspaper_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 660
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_significantDesign_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_significantDesign_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27142;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_significantDesign_delta_old" ON "dbrdf_significantDesign_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_significantDesign_delta_old" ON "dbrdf_significantDesign_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_significantDesign_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 661
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_wineRegion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_wineRegion_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27143;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_wineRegion_delta_old" ON "dbrdf_wineRegion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_wineRegion_delta_old" ON "dbrdf_wineRegion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_wineRegion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 662
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rocket_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rocket_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27144;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rocket_delta_old" ON "dbrdf_rocket_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rocket_delta_old" ON "dbrdf_rocket_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rocket_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 663
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_secondDriverCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_secondDriverCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27145;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_secondDriverCountry_delta_old" ON "dbrdf_secondDriverCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_secondDriverCountry_delta_old" ON "dbrdf_secondDriverCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_secondDriverCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 664
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 665
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_port2DockedTime_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_port2DockedTime_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27147;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_port2DockedTime_delta_old" ON "dbrdf_port2DockedTime_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_port2DockedTime_delta_old" ON "dbrdf_port2DockedTime_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_port2DockedTime_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 666
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lowestState_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lowestState_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27148;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lowestState_delta_old" ON "dbrdf_lowestState_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lowestState_delta_old" ON "dbrdf_lowestState_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lowestState_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 667
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 668
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nationalFilmAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nationalFilmAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27150;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nationalFilmAward_delta_old" ON "dbrdf_nationalFilmAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nationalFilmAward_delta_old" ON "dbrdf_nationalFilmAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nationalFilmAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 669
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_fees_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_fees_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27151;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_fees_delta_old" ON "dbrdf_fees_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_fees_delta_old" ON "dbrdf_fees_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_fees_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 670
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_discovered_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_discovered_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27152;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_discovered_delta_old" ON "dbrdf_discovered_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_discovered_delta_old" ON "dbrdf_discovered_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_discovered_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 671
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_coronationDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_coronationDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27153;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_coronationDate_delta_old" ON "dbrdf_coronationDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_coronationDate_delta_old" ON "dbrdf_coronationDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_coronationDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 672
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_academyAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_academyAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27154;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_academyAward_delta_old" ON "dbrdf_academyAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_academyAward_delta_old" ON "dbrdf_academyAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_academyAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 673
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Continent_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Continent_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27155;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Continent_delta_old" ON "dbrdf_Continent_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Continent_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Continent_delta_old0"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Continent_delta_old0"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27156;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Continent_delta_old0" ON "dbrdf_Continent_delta_old0"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Continent_delta_new0"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- <http://dbpedia.org/ontology/Continent$delta_new>(?Y) :- <http://dbpedia.org/ontology/Continent$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Continent_delta_new"(s) SELECT t1.o FROM "dbrdf_Continent_delta_old" t0, "__triples" t1 WHERE 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 = 27155);


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


        -- <http://schema.org/Continent$delta_new>(?Y) :- <http://schema.org/Continent$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Continent_delta_new0"(s) SELECT t1.o FROM "dbrdf_Continent_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 = 27156);


        -- Propagate $delta_new

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

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27156 FROM "dbrdf_Continent_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_Continent_delta_old0";
        INSERT INTO "dbrdf_Continent_delta_old0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Continent_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_Continent_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 674
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_oilSystem_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_oilSystem_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27157;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_oilSystem_delta_old" ON "dbrdf_oilSystem_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_oilSystem_delta_old" ON "dbrdf_oilSystem_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_oilSystem_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 675
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_secretaryGeneral_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_secretaryGeneral_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27158;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_secretaryGeneral_delta_old" ON "dbrdf_secretaryGeneral_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_secretaryGeneral_delta_old" ON "dbrdf_secretaryGeneral_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_secretaryGeneral_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 676
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 677
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfLiveAlbums_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfLiveAlbums_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27160;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfLiveAlbums_delta_old" ON "dbrdf_numberOfLiveAlbums_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfLiveAlbums_delta_old" ON "dbrdf_numberOfLiveAlbums_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfLiveAlbums_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 678
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_distanceToDouglas_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_distanceToDouglas_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27161;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_distanceToDouglas_delta_old" ON "dbrdf_distanceToDouglas_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_distanceToDouglas_delta_old" ON "dbrdf_distanceToDouglas_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_distanceToDouglas_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 679
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_medlineplus_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_medlineplus_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27162;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_medlineplus_delta_old" ON "dbrdf_medlineplus_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_medlineplus_delta_old" ON "dbrdf_medlineplus_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_medlineplus_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 680
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 681
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_unknownOutcomes_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_unknownOutcomes_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27164;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_unknownOutcomes_delta_old" ON "dbrdf_unknownOutcomes_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_unknownOutcomes_delta_old" ON "dbrdf_unknownOutcomes_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_unknownOutcomes_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 682
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_command_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_command_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27165;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_command_delta_old" ON "dbrdf_command_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_command_delta_old" ON "dbrdf_command_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_command_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 683
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 684
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_draftRound_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_draftRound_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27167;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_draftRound_delta_old" ON "dbrdf_draftRound_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_draftRound_delta_old" ON "dbrdf_draftRound_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_draftRound_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 685
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_registration_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_registration_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27168;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_registration_delta_old" ON "dbrdf_registration_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_registration_delta_old" ON "dbrdf_registration_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_registration_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 686
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_shareOfAudience_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_shareOfAudience_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27169;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_shareOfAudience_delta_old" ON "dbrdf_shareOfAudience_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_shareOfAudience_delta_old" ON "dbrdf_shareOfAudience_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_shareOfAudience_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 687
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_shipDisplacement_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_shipDisplacement_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27170;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_shipDisplacement_delta_old" ON "dbrdf_shipDisplacement_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_shipDisplacement_delta_old" ON "dbrdf_shipDisplacement_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_shipDisplacement_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 688
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_subsequentInfrastructure_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_subsequentInfrastructure_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27171;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_subsequentInfrastructure_delta_old" ON "dbrdf_subsequentInfrastructure_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_subsequentInfrastructure_delta_old" ON "dbrdf_subsequentInfrastructure_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_subsequentInfrastructure_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 689
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_school_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_school_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27172;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_school_delta_old" ON "dbrdf_school_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_school_delta_old" ON "dbrdf_school_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_school_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 690
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_range_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_range_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27173;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_range_delta_old" ON "dbrdf_range_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_range_delta_old" ON "dbrdf_range_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_range_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 691
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_pistonStroke_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_pistonStroke_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27174;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_pistonStroke_delta_old" ON "dbrdf_pistonStroke_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_pistonStroke_delta_old" ON "dbrdf_pistonStroke_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_pistonStroke_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 694
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_operatedBy_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_operatedBy_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27177;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_operatedBy_delta_old" ON "dbrdf_operatedBy_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_operatedBy_delta_old" ON "dbrdf_operatedBy_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_operatedBy_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 695
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_added_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_added_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27178;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_added_delta_old" ON "dbrdf_added_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_added_delta_old" ON "dbrdf_added_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_added_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 696
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_presenter_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_presenter_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27179;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_presenter_delta_old" ON "dbrdf_presenter_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_presenter_delta_old" ON "dbrdf_presenter_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_presenter_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 697
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_settingOfPlay_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_settingOfPlay_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27180;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_settingOfPlay_delta_old" ON "dbrdf_settingOfPlay_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_settingOfPlay_delta_old" ON "dbrdf_settingOfPlay_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_settingOfPlay_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 698
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_port2UndockingDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_port2UndockingDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27181;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_port2UndockingDate_delta_old" ON "dbrdf_port2UndockingDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_port2UndockingDate_delta_old" ON "dbrdf_port2UndockingDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_port2UndockingDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 699
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_order_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_order_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27182;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_order_delta_old" ON "dbrdf_order_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_order_delta_old" ON "dbrdf_order_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_order_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 700
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_governmentPlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_governmentPlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27183;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_governmentPlace_delta_old" ON "dbrdf_governmentPlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_governmentPlace_delta_old" ON "dbrdf_governmentPlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_governmentPlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 701
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_boiler_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_boiler_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27184;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_boiler_delta_old" ON "dbrdf_boiler_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_boiler_delta_old" ON "dbrdf_boiler_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_boiler_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 702
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtMajors_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtMajors_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27185;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtMajors_delta_old" ON "dbrdf_winsAtMajors_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtMajors_delta_old" ON "dbrdf_winsAtMajors_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtMajors_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 703
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ground_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ground_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27186;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ground_delta_old" ON "dbrdf_ground_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ground_delta_old" ON "dbrdf_ground_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ground_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 704
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_course_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_course_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27187;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_course_delta_old" ON "dbrdf_course_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_course_delta_old" ON "dbrdf_course_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_course_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 705
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_visitorsPerDay_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_visitorsPerDay_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27188;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_visitorsPerDay_delta_old" ON "dbrdf_visitorsPerDay_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_visitorsPerDay_delta_old" ON "dbrdf_visitorsPerDay_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_visitorsPerDay_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_noteOnPlaceOfBurial_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_noteOnPlaceOfBurial_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27190;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_noteOnPlaceOfBurial_delta_old" ON "dbrdf_noteOnPlaceOfBurial_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_noteOnPlaceOfBurial_delta_old" ON "dbrdf_noteOnPlaceOfBurial_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_noteOnPlaceOfBurial_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 708
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_show_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_show_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27191;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_show_delta_old" ON "dbrdf_show_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_show_delta_old" ON "dbrdf_show_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_show_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 709
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_binomialAuthority_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_binomialAuthority_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27192;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_binomialAuthority_delta_old" ON "dbrdf_binomialAuthority_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_binomialAuthority_delta_old" ON "dbrdf_binomialAuthority_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_binomialAuthority_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 710
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 711
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_humanDevelopmentIndex_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_humanDevelopmentIndex_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27194;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_humanDevelopmentIndex_delta_old" ON "dbrdf_humanDevelopmentIndex_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_humanDevelopmentIndex_delta_old" ON "dbrdf_humanDevelopmentIndex_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_humanDevelopmentIndex_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 712
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 713
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_war_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_war_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27196;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_war_delta_old" ON "dbrdf_war_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_war_delta_old" ON "dbrdf_war_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_war_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 714
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_date_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_date_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27197;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_date_delta_old" ON "dbrdf_date_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_date_delta_old" ON "dbrdf_date_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_date_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 715
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_displacement_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_displacement_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27198;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_displacement_delta_old0" ON "dbrdf_displacement_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_displacement_delta_old0" ON "dbrdf_displacement_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_displacement_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/AutomobileEngine/displacement$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/AutomobileEngine/displacement$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_displacement_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_displacement_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 = 27198 AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27198, t0.o FROM "dbrdf_displacement_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_displacement_delta_old0";
        INSERT INTO "dbrdf_displacement_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_displacement_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_displacement_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 716
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 717
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_averageSpeed_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_averageSpeed_delta_old1"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27200;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_averageSpeed_delta_old1" ON "dbrdf_averageSpeed_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_averageSpeed_delta_old1" ON "dbrdf_averageSpeed_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_averageSpeed_delta_new1"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27200, t0.o FROM "dbrdf_averageSpeed_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_averageSpeed_delta_old1";
        INSERT INTO "dbrdf_averageSpeed_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_averageSpeed_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_averageSpeed_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 718
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_makeupArtist_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_makeupArtist_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27201;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_makeupArtist_delta_old" ON "dbrdf_makeupArtist_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_makeupArtist_delta_old" ON "dbrdf_makeupArtist_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_makeupArtist_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 719
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_computingPlatform_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_computingPlatform_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27202;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_computingPlatform_delta_old" ON "dbrdf_computingPlatform_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_computingPlatform_delta_old" ON "dbrdf_computingPlatform_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_computingPlatform_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 720
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_house_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_house_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27203;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_house_delta_old" ON "dbrdf_house_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_house_delta_old" ON "dbrdf_house_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_house_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 721
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_twinCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_twinCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27204;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_twinCountry_delta_old" ON "dbrdf_twinCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_twinCountry_delta_old" ON "dbrdf_twinCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_twinCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 722
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_governmentType_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_governmentType_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27205;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_governmentType_delta_old" ON "dbrdf_governmentType_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_governmentType_delta_old" ON "dbrdf_governmentType_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_governmentType_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 723
    ---- DEPENDS ON: 722, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/GovernmentType>(?X1) :- <http://dbpedia.org/ontology/governmentType>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.o, 2, 27206 FROM "__triples" t0 WHERE t0.p = 27205 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.o AND ex.p = 2 AND ex.o = 27206);
    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_GovernmentType_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_GovernmentType_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27206;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_GovernmentType_delta_old" ON "dbrdf_GovernmentType_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_GovernmentType_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/GovernmentType$delta_new>(?Y) :- <http://dbpedia.org/ontology/GovernmentType$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_GovernmentType_delta_new"(s) SELECT t1.o FROM "dbrdf_GovernmentType_delta_old" t0, "__triples" t1 WHERE 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 = 27206);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 724
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_inclination_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_inclination_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27207;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_inclination_delta_old" ON "dbrdf_inclination_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_inclination_delta_old" ON "dbrdf_inclination_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_inclination_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 725
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_phylum_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_phylum_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27208;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_phylum_delta_old" ON "dbrdf_phylum_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_phylum_delta_old" ON "dbrdf_phylum_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_phylum_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 726
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_powerOutput_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_powerOutput_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27209;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_powerOutput_delta_old0" ON "dbrdf_powerOutput_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_powerOutput_delta_old0" ON "dbrdf_powerOutput_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_powerOutput_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/AutomobileEngine/powerOutput$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/AutomobileEngine/powerOutput$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_powerOutput_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_powerOutput_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 = 27209 AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27209, t0.o FROM "dbrdf_powerOutput_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_powerOutput_delta_old0";
        INSERT INTO "dbrdf_powerOutput_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_powerOutput_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_powerOutput_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 727
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_partner_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_partner_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27210;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_partner_delta_old" ON "dbrdf_partner_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_partner_delta_old" ON "dbrdf_partner_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_partner_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 728
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_homeport_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_homeport_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27211;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_homeport_delta_old" ON "dbrdf_homeport_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_homeport_delta_old" ON "dbrdf_homeport_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_homeport_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 729
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cargoWater_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cargoWater_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27212;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cargoWater_delta_old" ON "dbrdf_cargoWater_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_cargoWater_delta_old" ON "dbrdf_cargoWater_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cargoWater_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 730
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 731
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_spacewalkBegin_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_spacewalkBegin_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27214;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_spacewalkBegin_delta_old" ON "dbrdf_spacewalkBegin_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_spacewalkBegin_delta_old" ON "dbrdf_spacewalkBegin_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_spacewalkBegin_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 732
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_politicalPartyOfLeader_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_politicalPartyOfLeader_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27215;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_politicalPartyOfLeader_delta_old" ON "dbrdf_politicalPartyOfLeader_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_politicalPartyOfLeader_delta_old" ON "dbrdf_politicalPartyOfLeader_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_politicalPartyOfLeader_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 733
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 734
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_classification_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_classification_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27217;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_classification_delta_old" ON "dbrdf_classification_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_classification_delta_old" ON "dbrdf_classification_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_classification_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 735
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_militaryUnit_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_militaryUnit_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27218;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_militaryUnit_delta_old" ON "dbrdf_militaryUnit_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_militaryUnit_delta_old" ON "dbrdf_militaryUnit_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_militaryUnit_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 736
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_height_delta_old2"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_height_delta_old2"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27219;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_height_delta_old2" ON "dbrdf_height_delta_old2"(s, o); CREATE INDEX "IDX_1_dbrdf_height_delta_old2" ON "dbrdf_height_delta_old2"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_height_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/Weapon/height$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Weapon/height$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_height_delta_new2"(s, o) SELECT t1.o, t0.o FROM "dbrdf_height_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 = 27219 AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27219, t0.o FROM "dbrdf_height_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_height_delta_old2";
        INSERT INTO "dbrdf_height_delta_old2"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_height_delta_new2" t0;
        TRUNCATE TABLE "dbrdf_height_delta_new2";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 737
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_motto_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_motto_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27220;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_motto_delta_old" ON "dbrdf_motto_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_motto_delta_old" ON "dbrdf_motto_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_motto_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 738
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_impactFactor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_impactFactor_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27221;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_impactFactor_delta_old" ON "dbrdf_impactFactor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_impactFactor_delta_old" ON "dbrdf_impactFactor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_impactFactor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 739
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerChoreographer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_formerChoreographer_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27222;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_formerChoreographer_delta_old" ON "dbrdf_formerChoreographer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_formerChoreographer_delta_old" ON "dbrdf_formerChoreographer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerChoreographer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 740
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_causalties_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_causalties_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27223;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_causalties_delta_old" ON "dbrdf_causalties_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_causalties_delta_old" ON "dbrdf_causalties_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_causalties_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 741
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_participant_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_participant_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27224;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_participant_delta_old" ON "dbrdf_participant_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_participant_delta_old" ON "dbrdf_participant_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_participant_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 742
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nominee_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nominee_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27225;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nominee_delta_old" ON "dbrdf_nominee_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nominee_delta_old" ON "dbrdf_nominee_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nominee_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 743
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_olympicOathSwornByAthlete_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_olympicOathSwornByAthlete_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27226;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_olympicOathSwornByAthlete_delta_old" ON "dbrdf_olympicOathSwornByAthlete_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_olympicOathSwornByAthlete_delta_old" ON "dbrdf_olympicOathSwornByAthlete_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_olympicOathSwornByAthlete_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 744
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mgiid_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mgiid_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27227;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mgiid_delta_old" ON "dbrdf_mgiid_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mgiid_delta_old" ON "dbrdf_mgiid_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mgiid_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 745
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_vehicleCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_vehicleCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27228;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_vehicleCode_delta_old" ON "dbrdf_vehicleCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_vehicleCode_delta_old" ON "dbrdf_vehicleCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_vehicleCode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 746
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_irishName_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_irishName_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27229;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_irishName_delta_old" ON "dbrdf_irishName_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_irishName_delta_old" ON "dbrdf_irishName_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_irishName_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 747
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_splitFromParty_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_splitFromParty_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27230;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_splitFromParty_delta_old" ON "dbrdf_splitFromParty_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_splitFromParty_delta_old" ON "dbrdf_splitFromParty_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_splitFromParty_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 748
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ethnicity_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ethnicity_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27231;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ethnicity_delta_old" ON "dbrdf_ethnicity_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ethnicity_delta_old" ON "dbrdf_ethnicity_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ethnicity_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 749
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_prominence_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_prominence_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27232;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_prominence_delta_old" ON "dbrdf_prominence_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_prominence_delta_old" ON "dbrdf_prominence_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_prominence_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 750
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 751
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_airDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_airDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27234;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_airDate_delta_old" ON "dbrdf_airDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_airDate_delta_old" ON "dbrdf_airDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_airDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 752
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 753
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 754
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_icdo_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_icdo_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27237;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_icdo_delta_old" ON "dbrdf_icdo_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_icdo_delta_old" ON "dbrdf_icdo_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_icdo_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 755
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_countryWithFirstAstronaut_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_countryWithFirstAstronaut_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27238;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_countryWithFirstAstronaut_delta_old" ON "dbrdf_countryWithFirstAstronaut_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_countryWithFirstAstronaut_delta_old" ON "dbrdf_countryWithFirstAstronaut_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_countryWithFirstAstronaut_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 756
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_crews_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_crews_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27239;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_crews_delta_old" ON "dbrdf_crews_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_crews_delta_old" ON "dbrdf_crews_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_crews_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 757
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_code_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_code_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27240;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_code_delta_old" ON "dbrdf_code_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_code_delta_old" ON "dbrdf_code_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_code_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 758
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 759
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftFighter_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftFighter_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27242;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftFighter_delta_old" ON "dbrdf_aircraftFighter_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftFighter_delta_old" ON "dbrdf_aircraftFighter_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftFighter_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 760
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerHighschool_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_formerHighschool_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27243;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_formerHighschool_delta_old" ON "dbrdf_formerHighschool_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_formerHighschool_delta_old" ON "dbrdf_formerHighschool_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerHighschool_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 761
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_seasonNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_seasonNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27244;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_seasonNumber_delta_old" ON "dbrdf_seasonNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_seasonNumber_delta_old" ON "dbrdf_seasonNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_seasonNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 762
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mostPopulousCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mostPopulousCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27245;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mostPopulousCountry_delta_old" ON "dbrdf_mostPopulousCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mostPopulousCountry_delta_old" ON "dbrdf_mostPopulousCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mostPopulousCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 763
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_license_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_license_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27246;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_license_delta_old" ON "dbrdf_license_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_license_delta_old" ON "dbrdf_license_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_license_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 764
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_railGauge_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_railGauge_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27247;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_railGauge_delta_old" ON "dbrdf_railGauge_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_railGauge_delta_old" ON "dbrdf_railGauge_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_railGauge_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 765
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_vicePrimeMinister_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_vicePrimeMinister_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27248;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_vicePrimeMinister_delta_old" ON "dbrdf_vicePrimeMinister_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_vicePrimeMinister_delta_old" ON "dbrdf_vicePrimeMinister_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_vicePrimeMinister_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_largestSettlement_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_largestSettlement_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27250;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_largestSettlement_delta_old" ON "dbrdf_largestSettlement_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_largestSettlement_delta_old" ON "dbrdf_largestSettlement_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_largestSettlement_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 768
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastLaunch_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lastLaunch_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27251;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lastLaunch_delta_old" ON "dbrdf_lastLaunch_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lastLaunch_delta_old" ON "dbrdf_lastLaunch_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastLaunch_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 769
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_bSide_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_bSide_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27252;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_bSide_delta_old" ON "dbrdf_bSide_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_bSide_delta_old" ON "dbrdf_bSide_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_bSide_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 770
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dateConstruction_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dateConstruction_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27253;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dateConstruction_delta_old" ON "dbrdf_dateConstruction_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dateConstruction_delta_old" ON "dbrdf_dateConstruction_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dateConstruction_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 771
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsSubsection_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_alpsSubsection_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27254;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_alpsSubsection_delta_old" ON "dbrdf_alpsSubsection_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_alpsSubsection_delta_old" ON "dbrdf_alpsSubsection_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsSubsection_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 772
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_outflow_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_outflow_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27255;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_outflow_delta_old" ON "dbrdf_outflow_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_outflow_delta_old" ON "dbrdf_outflow_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_outflow_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 773
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_musicSubgenre_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_musicSubgenre_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27256;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_musicSubgenre_delta_old" ON "dbrdf_musicSubgenre_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_musicSubgenre_delta_old" ON "dbrdf_musicSubgenre_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_musicSubgenre_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 774
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 775
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_premiereYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_premiereYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27258;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_premiereYear_delta_old" ON "dbrdf_premiereYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_premiereYear_delta_old" ON "dbrdf_premiereYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_premiereYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 776
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationDensity_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_populationDensity_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27259;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_populationDensity_delta_old0" ON "dbrdf_populationDensity_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_populationDensity_delta_old0" ON "dbrdf_populationDensity_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationDensity_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/PopulatedPlace/populationDensity$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/PopulatedPlace/populationDensity$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_populationDensity_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_populationDensity_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 = 27259 AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27259, t0.o FROM "dbrdf_populationDensity_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_populationDensity_delta_old0";
        INSERT INTO "dbrdf_populationDensity_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_populationDensity_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_populationDensity_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 777
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaWater_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_areaWater_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27260;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_areaWater_delta_old" ON "dbrdf_areaWater_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_areaWater_delta_old" ON "dbrdf_areaWater_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaWater_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 778
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_landingSite_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_landingSite_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27261;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_landingSite_delta_old" ON "dbrdf_landingSite_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_landingSite_delta_old" ON "dbrdf_landingSite_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_landingSite_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 779
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_borough_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_borough_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27262;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_borough_delta_old" ON "dbrdf_borough_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_borough_delta_old" ON "dbrdf_borough_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_borough_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 780
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_totalLaunches_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_totalLaunches_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27263;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_totalLaunches_delta_old" ON "dbrdf_totalLaunches_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_totalLaunches_delta_old" ON "dbrdf_totalLaunches_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_totalLaunches_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 781
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectEndDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_projectEndDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27264;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_projectEndDate_delta_old" ON "dbrdf_projectEndDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_projectEndDate_delta_old" ON "dbrdf_projectEndDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectEndDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 782
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsMajorSector_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_alpsMajorSector_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27265;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_alpsMajorSector_delta_old" ON "dbrdf_alpsMajorSector_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_alpsMajorSector_delta_old" ON "dbrdf_alpsMajorSector_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsMajorSector_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 783
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_athletics_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_athletics_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27266;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_athletics_delta_old" ON "dbrdf_athletics_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_athletics_delta_old" ON "dbrdf_athletics_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_athletics_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 784
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_associationOfLocalGovernment_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_associationOfLocalGovernment_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27267;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_associationOfLocalGovernment_delta_old" ON "dbrdf_associationOfLocalGovernment_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_associationOfLocalGovernment_delta_old" ON "dbrdf_associationOfLocalGovernment_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_associationOfLocalGovernment_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 785
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_clubsRecordGoalscorer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_clubsRecordGoalscorer_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27268;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_clubsRecordGoalscorer_delta_old" ON "dbrdf_clubsRecordGoalscorer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_clubsRecordGoalscorer_delta_old" ON "dbrdf_clubsRecordGoalscorer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_clubsRecordGoalscorer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 786
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_facultySize_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_facultySize_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27269;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_facultySize_delta_old" ON "dbrdf_facultySize_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_facultySize_delta_old" ON "dbrdf_facultySize_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_facultySize_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 787
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_silverMedalist_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_silverMedalist_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27270;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_silverMedalist_delta_old" ON "dbrdf_silverMedalist_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_silverMedalist_delta_old" ON "dbrdf_silverMedalist_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_silverMedalist_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 788
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_subregion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_subregion_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27271;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_subregion_delta_old" ON "dbrdf_subregion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_subregion_delta_old" ON "dbrdf_subregion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_subregion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 789
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cosparId_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cosparId_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27272;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cosparId_delta_old" ON "dbrdf_cosparId_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_cosparId_delta_old" ON "dbrdf_cosparId_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cosparId_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 790
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_acquirementDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_acquirementDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27273;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_acquirementDate_delta_old" ON "dbrdf_acquirementDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_acquirementDate_delta_old" ON "dbrdf_acquirementDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_acquirementDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 791
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_density_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_density_delta_old1"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27274;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_density_delta_old1" ON "dbrdf_density_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_density_delta_old1" ON "dbrdf_density_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_density_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/ChemicalSubstance/density$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/ChemicalSubstance/density$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_density_delta_new1"(s, o) SELECT t1.o, t0.o FROM "dbrdf_density_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 = 27274 AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27274, t0.o FROM "dbrdf_density_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_density_delta_old1";
        INSERT INTO "dbrdf_density_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_density_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_density_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 792
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_varietals_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_varietals_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27275;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_varietals_delta_old" ON "dbrdf_varietals_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_varietals_delta_old" ON "dbrdf_varietals_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_varietals_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 793
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_latestReleaseVersion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_latestReleaseVersion_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27276;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_latestReleaseVersion_delta_old" ON "dbrdf_latestReleaseVersion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_latestReleaseVersion_delta_old" ON "dbrdf_latestReleaseVersion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_latestReleaseVersion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 794
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_beatifiedBy_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_beatifiedBy_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27277;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_beatifiedBy_delta_old" ON "dbrdf_beatifiedBy_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_beatifiedBy_delta_old" ON "dbrdf_beatifiedBy_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_beatifiedBy_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 795
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 796
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_originalLanguage_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_originalLanguage_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27279;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_originalLanguage_delta_old" ON "dbrdf_originalLanguage_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_originalLanguage_delta_old" ON "dbrdf_originalLanguage_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_originalLanguage_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 797
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftUser_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftUser_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27280;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftUser_delta_old" ON "dbrdf_aircraftUser_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftUser_delta_old" ON "dbrdf_aircraftUser_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftUser_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 798
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationTotalRanking_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_populationTotalRanking_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27281;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_populationTotalRanking_delta_old" ON "dbrdf_populationTotalRanking_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_populationTotalRanking_delta_old" ON "dbrdf_populationTotalRanking_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationTotalRanking_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 799
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaOfCatchment_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_areaOfCatchment_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27282;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_areaOfCatchment_delta_old" ON "dbrdf_areaOfCatchment_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_areaOfCatchment_delta_old" ON "dbrdf_areaOfCatchment_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaOfCatchment_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 800
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_distanceLaps_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_distanceLaps_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27283;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_distanceLaps_delta_old" ON "dbrdf_distanceLaps_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_distanceLaps_delta_old" ON "dbrdf_distanceLaps_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_distanceLaps_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 801
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_pubchem_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_pubchem_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27284;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_pubchem_delta_old" ON "dbrdf_pubchem_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_pubchem_delta_old" ON "dbrdf_pubchem_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_pubchem_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 802
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_selection_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_selection_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27285;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_selection_delta_old" ON "dbrdf_selection_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_selection_delta_old" ON "dbrdf_selection_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_selection_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 803
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstLaunchRocket_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstLaunchRocket_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27286;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstLaunchRocket_delta_old" ON "dbrdf_firstLaunchRocket_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstLaunchRocket_delta_old" ON "dbrdf_firstLaunchRocket_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstLaunchRocket_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 804
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastFlight_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lastFlight_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27287;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lastFlight_delta_old" ON "dbrdf_lastFlight_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lastFlight_delta_old" ON "dbrdf_lastFlight_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastFlight_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 805
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_networth_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_networth_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27288;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_networth_delta_old" ON "dbrdf_networth_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_networth_delta_old" ON "dbrdf_networth_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_networth_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 806
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27289, t0.o FROM "dbrdf_freeFlightTime_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_freeFlightTime_delta_old0";
        INSERT INTO "dbrdf_freeFlightTime_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_freeFlightTime_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_freeFlightTime_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 807
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_significantBuilding_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_significantBuilding_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27290;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_significantBuilding_delta_old" ON "dbrdf_significantBuilding_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_significantBuilding_delta_old" ON "dbrdf_significantBuilding_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_significantBuilding_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 808
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_visitorsPerYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_visitorsPerYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27291;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_visitorsPerYear_delta_old" ON "dbrdf_visitorsPerYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_visitorsPerYear_delta_old" ON "dbrdf_visitorsPerYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_visitorsPerYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 809
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastLaunchRocket_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lastLaunchRocket_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27292;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lastLaunchRocket_delta_old" ON "dbrdf_lastLaunchRocket_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lastLaunchRocket_delta_old" ON "dbrdf_lastLaunchRocket_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastLaunchRocket_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 810
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectReferenceID_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_projectReferenceID_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27293;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_projectReferenceID_delta_old" ON "dbrdf_projectReferenceID_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_projectReferenceID_delta_old" ON "dbrdf_projectReferenceID_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectReferenceID_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 811
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mirDockings_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mirDockings_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27294;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mirDockings_delta_old" ON "dbrdf_mirDockings_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mirDockings_delta_old" ON "dbrdf_mirDockings_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mirDockings_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 812
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationRural_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_populationRural_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27295;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_populationRural_delta_old" ON "dbrdf_populationRural_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_populationRural_delta_old" ON "dbrdf_populationRural_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationRural_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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