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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 303
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_programmingLanguage_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_programmingLanguage_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26785;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_programmingLanguage_delta_old" ON "dbrdf_programmingLanguage_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_programmingLanguage_delta_old" ON "dbrdf_programmingLanguage_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_programmingLanguage_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 304
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26786, t0.o FROM "dbrdf_meanTemperature_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_meanTemperature_delta_old0";
        INSERT INTO "dbrdf_meanTemperature_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_meanTemperature_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_meanTemperature_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 305
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_portrayer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_portrayer_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26787;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_portrayer_delta_old" ON "dbrdf_portrayer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_portrayer_delta_old" ON "dbrdf_portrayer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_portrayer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 306
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_coolingSystem_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_coolingSystem_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26788;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_coolingSystem_delta_old" ON "dbrdf_coolingSystem_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_coolingSystem_delta_old" ON "dbrdf_coolingSystem_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_coolingSystem_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 307
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_fc_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_fc_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26789;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_fc_delta_old" ON "dbrdf_fc_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_fc_delta_old" ON "dbrdf_fc_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_fc_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 308
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_managementCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_managementCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26790;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_managementCountry_delta_old" ON "dbrdf_managementCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_managementCountry_delta_old" ON "dbrdf_managementCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_managementCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 309
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 310
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_battingSide_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_battingSide_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26792;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_battingSide_delta_old" ON "dbrdf_battingSide_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_battingSide_delta_old" ON "dbrdf_battingSide_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_battingSide_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 311
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nisCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nisCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26793;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nisCode_delta_old" ON "dbrdf_nisCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nisCode_delta_old" ON "dbrdf_nisCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nisCode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 312
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_influenced_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_influenced_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26794;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_influenced_delta_old" ON "dbrdf_influenced_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_influenced_delta_old" ON "dbrdf_influenced_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_influenced_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 313
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_endYearOfInsertion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_endYearOfInsertion_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26795;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_endYearOfInsertion_delta_old" ON "dbrdf_endYearOfInsertion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_endYearOfInsertion_delta_old" ON "dbrdf_endYearOfInsertion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_endYearOfInsertion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 314
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_productionCompany_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_productionCompany_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26796;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_productionCompany_delta_old" ON "dbrdf_productionCompany_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_productionCompany_delta_old" ON "dbrdf_productionCompany_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_productionCompany_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 315
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_entrezgene_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_entrezgene_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26797;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_entrezgene_delta_old" ON "dbrdf_entrezgene_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_entrezgene_delta_old" ON "dbrdf_entrezgene_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_entrezgene_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 316
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_colourName_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_colourName_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26798;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_colourName_delta_old" ON "dbrdf_colourName_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_colourName_delta_old" ON "dbrdf_colourName_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_colourName_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 317
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lunarEvaTime_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lunarEvaTime_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26799;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lunarEvaTime_delta_old" ON "dbrdf_lunarEvaTime_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lunarEvaTime_delta_old" ON "dbrdf_lunarEvaTime_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lunarEvaTime_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 318
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 319
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mostWins_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mostWins_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26801;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mostWins_delta_old" ON "dbrdf_mostWins_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mostWins_delta_old" ON "dbrdf_mostWins_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mostWins_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 320
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 321
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_college_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_college_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26803;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_college_delta_old" ON "dbrdf_college_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_college_delta_old" ON "dbrdf_college_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_college_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 322
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_railwayRollingStock_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_railwayRollingStock_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26804;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_railwayRollingStock_delta_old" ON "dbrdf_railwayRollingStock_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_railwayRollingStock_delta_old" ON "dbrdf_railwayRollingStock_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_railwayRollingStock_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 323
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 324
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26806, t0.o FROM "dbrdf_orbitalPeriod_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_orbitalPeriod_delta_old0";
        INSERT INTO "dbrdf_orbitalPeriod_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_orbitalPeriod_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_orbitalPeriod_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 325
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ranking_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ranking_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26807;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ranking_delta_old" ON "dbrdf_ranking_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ranking_delta_old" ON "dbrdf_ranking_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ranking_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 326
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_topLevelDomain_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_topLevelDomain_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26808;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_topLevelDomain_delta_old" ON "dbrdf_topLevelDomain_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_topLevelDomain_delta_old" ON "dbrdf_topLevelDomain_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_topLevelDomain_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 327
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_finalPublicationYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_finalPublicationYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26809;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_finalPublicationYear_delta_old" ON "dbrdf_finalPublicationYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_finalPublicationYear_delta_old" ON "dbrdf_finalPublicationYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_finalPublicationYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 328
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nationalAffiliation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nationalAffiliation_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26810;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nationalAffiliation_delta_old" ON "dbrdf_nationalAffiliation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nationalAffiliation_delta_old" ON "dbrdf_nationalAffiliation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nationalAffiliation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 329
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_anthem_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_anthem_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26811;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_anthem_delta_old" ON "dbrdf_anthem_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_anthem_delta_old" ON "dbrdf_anthem_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_anthem_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 330
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfCompetitors_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfCompetitors_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26812;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfCompetitors_delta_old" ON "dbrdf_numberOfCompetitors_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfCompetitors_delta_old" ON "dbrdf_numberOfCompetitors_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfCompetitors_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 331
    ---- 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 = 26813;
    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 = 26814;
    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://schema.org/Continent$delta_new>(?X) :- <http://dbpedia.org/ontology/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 = 26813);


        -- <http://schema.org/Continent$delta_new>(?Y) :- <http://schema.org/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 = 26813);


        -- <http://dbpedia.org/ontology/Continent$delta_new>(?X) :- <http://schema.org/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 = 26814);


        -- <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_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 = 26814);


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mediaType_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mediaType_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26815;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mediaType_delta_old" ON "dbrdf_mediaType_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mediaType_delta_old" ON "dbrdf_mediaType_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mediaType_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 333
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 334
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26817, t0.o FROM "dbrdf_length_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_length_delta_old1";
        INSERT INTO "dbrdf_length_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_length_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_length_delta_new1";

    END LOOP;

    -- END Recursive rules

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


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 337
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_giniCoefficientCategory_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_giniCoefficientCategory_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26820;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_giniCoefficientCategory_delta_old" ON "dbrdf_giniCoefficientCategory_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_giniCoefficientCategory_delta_old" ON "dbrdf_giniCoefficientCategory_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_giniCoefficientCategory_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 338
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_highestRegion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_highestRegion_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26821;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_highestRegion_delta_old" ON "dbrdf_highestRegion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_highestRegion_delta_old" ON "dbrdf_highestRegion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_highestRegion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 339
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_associatedAct_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_associatedAct_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26822;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_associatedAct_delta_old" ON "dbrdf_associatedAct_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_associatedAct_delta_old" ON "dbrdf_associatedAct_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_associatedAct_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 340
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtAsia_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtAsia_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26823;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtAsia_delta_old" ON "dbrdf_winsAtAsia_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtAsia_delta_old" ON "dbrdf_winsAtAsia_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtAsia_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 341
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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


        -- Propagate $delta_new

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

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Priest>(?X) :- <http://dbpedia.org/ontology/ordination>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26826 FROM "__triples" t0 WHERE t0.p = 26521 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26826);
    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_Priest_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Priest_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26826;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Priest_delta_old" ON "dbrdf_Priest_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Priest_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/Priest$delta_new>(?Y) :- <http://dbpedia.org/ontology/Priest$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Priest_delta_new"(s) SELECT t1.o FROM "dbrdf_Priest_delta_old" t0, "__triples" t1 WHERE 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 = 26826);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 344
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_background_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_background_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26827;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_background_delta_old" ON "dbrdf_background_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_background_delta_old" ON "dbrdf_background_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_background_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 345
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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


        -- Propagate $delta_new

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


        -- Propagate $delta_new

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


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_issDockings_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_issDockings_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26832;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_issDockings_delta_old" ON "dbrdf_issDockings_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_issDockings_delta_old" ON "dbrdf_issDockings_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_issDockings_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 350
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_citizenship_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_citizenship_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26835;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_citizenship_delta_old" ON "dbrdf_citizenship_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_citizenship_delta_old" ON "dbrdf_citizenship_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_citizenship_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 353
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_duration_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_duration_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26836;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_duration_delta_old" ON "dbrdf_duration_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_duration_delta_old" ON "dbrdf_duration_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_duration_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 354
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_synonym_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_synonym_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26837;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_synonym_delta_old" ON "dbrdf_synonym_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_synonym_delta_old" ON "dbrdf_synonym_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_synonym_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 355
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_colourHexCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_colourHexCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26838;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_colourHexCode_delta_old" ON "dbrdf_colourHexCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_colourHexCode_delta_old" ON "dbrdf_colourHexCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_colourHexCode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 356
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_volume_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_volume_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26839;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_volume_delta_old0" ON "dbrdf_volume_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_volume_delta_old0" ON "dbrdf_volume_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_volume_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/SpaceStation/volume$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/SpaceStation/volume$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_volume_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_volume_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 = 26839 AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26839, t0.o FROM "dbrdf_volume_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_volume_delta_old0";
        INSERT INTO "dbrdf_volume_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_volume_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_volume_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 357
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 358
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_atcSuffix_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_atcSuffix_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26841;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_atcSuffix_delta_old" ON "dbrdf_atcSuffix_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_atcSuffix_delta_old" ON "dbrdf_atcSuffix_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_atcSuffix_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 359
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mouthState_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mouthState_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26842;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mouthState_delta_old" ON "dbrdf_mouthState_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mouthState_delta_old" ON "dbrdf_mouthState_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mouthState_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 360
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_governmentCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_governmentCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26843;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_governmentCountry_delta_old" ON "dbrdf_governmentCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_governmentCountry_delta_old" ON "dbrdf_governmentCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_governmentCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 361
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_endYearOfSales_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_endYearOfSales_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26844;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_endYearOfSales_delta_old" ON "dbrdf_endYearOfSales_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_endYearOfSales_delta_old" ON "dbrdf_endYearOfSales_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_endYearOfSales_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 362
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_growingGrape_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_growingGrape_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26845;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_growingGrape_delta_old" ON "dbrdf_growingGrape_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_growingGrape_delta_old" ON "dbrdf_growingGrape_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_growingGrape_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 363
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_epoch_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_epoch_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26846;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_epoch_delta_old" ON "dbrdf_epoch_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_epoch_delta_old" ON "dbrdf_epoch_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_epoch_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 364
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectParticipant_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_projectParticipant_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26847;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_projectParticipant_delta_old" ON "dbrdf_projectParticipant_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_projectParticipant_delta_old" ON "dbrdf_projectParticipant_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectParticipant_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 365
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_drugbank_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_drugbank_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26848;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_drugbank_delta_old" ON "dbrdf_drugbank_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_drugbank_delta_old" ON "dbrdf_drugbank_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_drugbank_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 366
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 367
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_committee_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_committee_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26850;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_committee_delta_old" ON "dbrdf_committee_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_committee_delta_old" ON "dbrdf_committee_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_committee_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 368
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_maidenFlight_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_maidenFlight_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26851;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_maidenFlight_delta_old" ON "dbrdf_maidenFlight_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_maidenFlight_delta_old" ON "dbrdf_maidenFlight_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_maidenFlight_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 369
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfOffices_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfOffices_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26852;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfOffices_delta_old" ON "dbrdf_numberOfOffices_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfOffices_delta_old" ON "dbrdf_numberOfOffices_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfOffices_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 370
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_minorityFloorLeader_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_minorityFloorLeader_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26853;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_minorityFloorLeader_delta_old" ON "dbrdf_minorityFloorLeader_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_minorityFloorLeader_delta_old" ON "dbrdf_minorityFloorLeader_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_minorityFloorLeader_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 371
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_britishComedyAwards_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_britishComedyAwards_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26854;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_britishComedyAwards_delta_old" ON "dbrdf_britishComedyAwards_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_britishComedyAwards_delta_old" ON "dbrdf_britishComedyAwards_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_britishComedyAwards_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 372
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dean_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dean_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26855;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dean_delta_old" ON "dbrdf_dean_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dean_delta_old" ON "dbrdf_dean_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dean_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 373
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cinematography_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cinematography_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26856;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cinematography_delta_old" ON "dbrdf_cinematography_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_cinematography_delta_old" ON "dbrdf_cinematography_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cinematography_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 374
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfSilverMedalsWon_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfSilverMedalsWon_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26857;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfSilverMedalsWon_delta_old" ON "dbrdf_numberOfSilverMedalsWon_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfSilverMedalsWon_delta_old" ON "dbrdf_numberOfSilverMedalsWon_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfSilverMedalsWon_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_powerType_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_powerType_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26859;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_powerType_delta_old" ON "dbrdf_powerType_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_powerType_delta_old" ON "dbrdf_powerType_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_powerType_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 377
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_silCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_silCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26860;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_silCode_delta_old" ON "dbrdf_silCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_silCode_delta_old" ON "dbrdf_silCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_silCode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 378
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 379
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 380
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 381
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_largestMetro_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_largestMetro_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26864;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_largestMetro_delta_old" ON "dbrdf_largestMetro_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_largestMetro_delta_old" ON "dbrdf_largestMetro_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_largestMetro_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 382
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_meshName_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_meshName_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26865;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_meshName_delta_old" ON "dbrdf_meshName_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_meshName_delta_old" ON "dbrdf_meshName_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_meshName_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 383
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_productionStartDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_productionStartDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26866;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_productionStartDate_delta_old" ON "dbrdf_productionStartDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_productionStartDate_delta_old" ON "dbrdf_productionStartDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_productionStartDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_canonizedPlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_canonizedPlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26868;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_canonizedPlace_delta_old" ON "dbrdf_canonizedPlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_canonizedPlace_delta_old" ON "dbrdf_canonizedPlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_canonizedPlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 386
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_service_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_service_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26869;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_service_delta_old" ON "dbrdf_service_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_service_delta_old" ON "dbrdf_service_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_service_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 387
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_shipCrew_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_shipCrew_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26870;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_shipCrew_delta_old" ON "dbrdf_shipCrew_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_shipCrew_delta_old" ON "dbrdf_shipCrew_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_shipCrew_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 388
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_inn_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_inn_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26871;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_inn_delta_old" ON "dbrdf_inn_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_inn_delta_old" ON "dbrdf_inn_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_inn_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 389
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfPiersInWater_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfPiersInWater_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26872;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfPiersInWater_delta_old" ON "dbrdf_numberOfPiersInWater_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfPiersInWater_delta_old" ON "dbrdf_numberOfPiersInWater_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfPiersInWater_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 390
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_state_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_state_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26873;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_state_delta_old" ON "dbrdf_state_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_state_delta_old" ON "dbrdf_state_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_state_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 391
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_recommissioningDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_recommissioningDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26874;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_recommissioningDate_delta_old" ON "dbrdf_recommissioningDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_recommissioningDate_delta_old" ON "dbrdf_recommissioningDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_recommissioningDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 392
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_designer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_designer_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26875;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_designer_delta_old" ON "dbrdf_designer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_designer_delta_old" ON "dbrdf_designer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_designer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 393
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_hallOfFame_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_hallOfFame_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26876;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_hallOfFame_delta_old" ON "dbrdf_hallOfFame_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_hallOfFame_delta_old" ON "dbrdf_hallOfFame_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_hallOfFame_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 394
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_fileSize_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_fileSize_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26877;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_fileSize_delta_old" ON "dbrdf_fileSize_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_fileSize_delta_old" ON "dbrdf_fileSize_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_fileSize_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 395
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_majorLake_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_majorLake_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26878;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_majorLake_delta_old" ON "dbrdf_majorLake_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_majorLake_delta_old" ON "dbrdf_majorLake_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_majorLake_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 396
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sessionNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sessionNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26879;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sessionNumber_delta_old" ON "dbrdf_sessionNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sessionNumber_delta_old" ON "dbrdf_sessionNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sessionNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 397
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_weddingParentsDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_weddingParentsDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26880;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_weddingParentsDate_delta_old" ON "dbrdf_weddingParentsDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_weddingParentsDate_delta_old" ON "dbrdf_weddingParentsDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_weddingParentsDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 398
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_vehicle_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_vehicle_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26881;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_vehicle_delta_old" ON "dbrdf_vehicle_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_vehicle_delta_old" ON "dbrdf_vehicle_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_vehicle_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 399
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 400
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lengthReference_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lengthReference_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26883;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lengthReference_delta_old" ON "dbrdf_lengthReference_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lengthReference_delta_old" ON "dbrdf_lengthReference_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lengthReference_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 401
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_chorusCharacterInPlay_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_chorusCharacterInPlay_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26886;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_chorusCharacterInPlay_delta_old" ON "dbrdf_chorusCharacterInPlay_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_chorusCharacterInPlay_delta_old" ON "dbrdf_chorusCharacterInPlay_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_chorusCharacterInPlay_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 404
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_icd10_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_icd10_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26887;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_icd10_delta_old" ON "dbrdf_icd10_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_icd10_delta_old" ON "dbrdf_icd10_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_icd10_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 405
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_equity_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_equity_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26888;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_equity_delta_old" ON "dbrdf_equity_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_equity_delta_old" ON "dbrdf_equity_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_equity_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 406
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_teachingStaff_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_teachingStaff_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26889;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_teachingStaff_delta_old" ON "dbrdf_teachingStaff_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_teachingStaff_delta_old" ON "dbrdf_teachingStaff_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_teachingStaff_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 407
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_federalState_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_federalState_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26890;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_federalState_delta_old" ON "dbrdf_federalState_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_federalState_delta_old" ON "dbrdf_federalState_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_federalState_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 408
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rotationPeriod_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rotationPeriod_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26891;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rotationPeriod_delta_old" ON "dbrdf_rotationPeriod_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rotationPeriod_delta_old" ON "dbrdf_rotationPeriod_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rotationPeriod_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 409
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_coach_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_coach_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26892;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_coach_delta_old" ON "dbrdf_coach_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_coach_delta_old" ON "dbrdf_coach_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_coach_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 410
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstRace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstRace_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26893;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstRace_delta_old" ON "dbrdf_firstRace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstRace_delta_old" ON "dbrdf_firstRace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstRace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 411
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_meltingPoint_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_meltingPoint_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26894;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_meltingPoint_delta_old" ON "dbrdf_meltingPoint_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_meltingPoint_delta_old" ON "dbrdf_meltingPoint_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_meltingPoint_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 412
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_areaCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26895;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_areaCode_delta_old" ON "dbrdf_areaCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_areaCode_delta_old" ON "dbrdf_areaCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaCode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 413
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_definition_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_definition_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26896;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_definition_delta_old" ON "dbrdf_definition_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_definition_delta_old" ON "dbrdf_definition_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_definition_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 414
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstLeader_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstLeader_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26897;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstLeader_delta_old" ON "dbrdf_firstLeader_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstLeader_delta_old" ON "dbrdf_firstLeader_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstLeader_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 415
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_other_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_other_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26898;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_other_delta_old" ON "dbrdf_other_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_other_delta_old" ON "dbrdf_other_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_other_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 416
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_basedOn_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_basedOn_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26899;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_basedOn_delta_old" ON "dbrdf_basedOn_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_basedOn_delta_old" ON "dbrdf_basedOn_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_basedOn_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 417
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_volume_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_volume_delta_old1"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26900;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_volume_delta_old1" ON "dbrdf_volume_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_volume_delta_old1" ON "dbrdf_volume_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_volume_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/Planet/volume$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Planet/volume$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_volume_delta_new1"(s, o) SELECT t1.o, t0.o FROM "dbrdf_volume_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 = 26900 AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26900, t0.o FROM "dbrdf_volume_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_volume_delta_old1";
        INSERT INTO "dbrdf_volume_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_volume_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_volume_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 418
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mouthPosition_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mouthPosition_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26901;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mouthPosition_delta_old" ON "dbrdf_mouthPosition_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mouthPosition_delta_old" ON "dbrdf_mouthPosition_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mouthPosition_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 419
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_premiereDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_premiereDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26902;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_premiereDate_delta_old" ON "dbrdf_premiereDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_premiereDate_delta_old" ON "dbrdf_premiereDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_premiereDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 420
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_valvetrain_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_valvetrain_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26903;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_valvetrain_delta_old" ON "dbrdf_valvetrain_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_valvetrain_delta_old" ON "dbrdf_valvetrain_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_valvetrain_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 421
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 422
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ingredient_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ingredient_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26905;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ingredient_delta_old" ON "dbrdf_ingredient_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ingredient_delta_old" ON "dbrdf_ingredient_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ingredient_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 423
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26906, t0.o FROM "dbrdf_meltingPoint_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_meltingPoint_delta_old0";
        INSERT INTO "dbrdf_meltingPoint_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_meltingPoint_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_meltingPoint_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 424
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_locusSupplementaryData_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_locusSupplementaryData_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26907;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_locusSupplementaryData_delta_old" ON "dbrdf_locusSupplementaryData_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_locusSupplementaryData_delta_old" ON "dbrdf_locusSupplementaryData_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_locusSupplementaryData_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 425
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_soccerTournamentClosingSeason_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_soccerTournamentClosingSeason_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26908;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_soccerTournamentClosingSeason_delta_old" ON "dbrdf_soccerTournamentClosingSeason_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_soccerTournamentClosingSeason_delta_old" ON "dbrdf_soccerTournamentClosingSeason_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_soccerTournamentClosingSeason_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 426
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rankingWins_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rankingWins_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26909;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rankingWins_delta_old" ON "dbrdf_rankingWins_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rankingWins_delta_old" ON "dbrdf_rankingWins_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rankingWins_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 427
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_managementMountain_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_managementMountain_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26910;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_managementMountain_delta_old" ON "dbrdf_managementMountain_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_managementMountain_delta_old" ON "dbrdf_managementMountain_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_managementMountain_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 430
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_fastestDriver_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_fastestDriver_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26913;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_fastestDriver_delta_old" ON "dbrdf_fastestDriver_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_fastestDriver_delta_old" ON "dbrdf_fastestDriver_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_fastestDriver_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 431
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 432
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_soccerTournamentMostSuccesfull_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_soccerTournamentMostSuccesfull_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26915;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_soccerTournamentMostSuccesfull_delta_old" ON "dbrdf_soccerTournamentMostSuccesfull_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_soccerTournamentMostSuccesfull_delta_old" ON "dbrdf_soccerTournamentMostSuccesfull_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_soccerTournamentMostSuccesfull_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 433
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_diseasesdb_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_diseasesdb_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26916;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_diseasesdb_delta_old" ON "dbrdf_diseasesdb_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_diseasesdb_delta_old" ON "dbrdf_diseasesdb_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_diseasesdb_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 434
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_soocerLeagueWinner_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_soocerLeagueWinner_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26917;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_soocerLeagueWinner_delta_old" ON "dbrdf_soocerLeagueWinner_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_soocerLeagueWinner_delta_old" ON "dbrdf_soocerLeagueWinner_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_soocerLeagueWinner_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 435
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 436
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sublimationPoint_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sublimationPoint_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26919;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sublimationPoint_delta_old" ON "dbrdf_sublimationPoint_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sublimationPoint_delta_old" ON "dbrdf_sublimationPoint_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sublimationPoint_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 437
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftHelicopter_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftHelicopter_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26920;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftHelicopter_delta_old" ON "dbrdf_aircraftHelicopter_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftHelicopter_delta_old" ON "dbrdf_aircraftHelicopter_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftHelicopter_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 438
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_testaverage_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_testaverage_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26921;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_testaverage_delta_old" ON "dbrdf_testaverage_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_testaverage_delta_old" ON "dbrdf_testaverage_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_testaverage_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_trackLength_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_trackLength_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26923;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_trackLength_delta_old" ON "dbrdf_trackLength_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_trackLength_delta_old" ON "dbrdf_trackLength_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_trackLength_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 441
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_promotion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_promotion_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26924;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_promotion_delta_old" ON "dbrdf_promotion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_promotion_delta_old" ON "dbrdf_promotion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_promotion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 442
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_band_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_band_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26925;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_band_delta_old" ON "dbrdf_band_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_band_delta_old" ON "dbrdf_band_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_band_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 443
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 444
    ---- DEPENDS ON: 201, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26927, t0.o FROM "dbrdf_starring_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_starring_delta_old0";
        INSERT INTO "dbrdf_starring_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_starring_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_starring_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 445
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26928, t0.o FROM "dbrdf_lunarEvaTime_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_lunarEvaTime_delta_old0";
        INSERT INTO "dbrdf_lunarEvaTime_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lunarEvaTime_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_lunarEvaTime_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 446
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfAlbums_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfAlbums_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26929;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfAlbums_delta_old" ON "dbrdf_numberOfAlbums_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfAlbums_delta_old" ON "dbrdf_numberOfAlbums_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfAlbums_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 447
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_productionStartYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_productionStartYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26930;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_productionStartYear_delta_old" ON "dbrdf_productionStartYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_productionStartYear_delta_old" ON "dbrdf_productionStartYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_productionStartYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 448
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_owningCompany_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_owningCompany_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26931;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_owningCompany_delta_old" ON "dbrdf_owningCompany_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_owningCompany_delta_old" ON "dbrdf_owningCompany_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_owningCompany_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 449
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_spokesperson_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_spokesperson_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26934;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_spokesperson_delta_old" ON "dbrdf_spokesperson_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_spokesperson_delta_old" ON "dbrdf_spokesperson_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_spokesperson_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 452
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_editorTitle_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_editorTitle_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26935;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_editorTitle_delta_old" ON "dbrdf_editorTitle_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_editorTitle_delta_old" ON "dbrdf_editorTitle_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_editorTitle_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 453
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_runwaySurface_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_runwaySurface_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26936;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_runwaySurface_delta_old" ON "dbrdf_runwaySurface_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_runwaySurface_delta_old" ON "dbrdf_runwaySurface_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_runwaySurface_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 454
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_governmentRegion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_governmentRegion_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26937;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_governmentRegion_delta_old" ON "dbrdf_governmentRegion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_governmentRegion_delta_old" ON "dbrdf_governmentRegion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_governmentRegion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 455
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_booster_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_booster_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26938;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_booster_delta_old" ON "dbrdf_booster_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_booster_delta_old" ON "dbrdf_booster_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_booster_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 456
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_openAccessContent_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_openAccessContent_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26939;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_openAccessContent_delta_old" ON "dbrdf_openAccessContent_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_openAccessContent_delta_old" ON "dbrdf_openAccessContent_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_openAccessContent_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 457
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_allegiance_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_allegiance_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26940;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_allegiance_delta_old" ON "dbrdf_allegiance_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_allegiance_delta_old" ON "dbrdf_allegiance_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_allegiance_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 458
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_captureDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_captureDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26941;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_captureDate_delta_old" ON "dbrdf_captureDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_captureDate_delta_old" ON "dbrdf_captureDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_captureDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 459
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_innervates_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_innervates_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26942;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_innervates_delta_old" ON "dbrdf_innervates_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_innervates_delta_old" ON "dbrdf_innervates_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_innervates_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 460
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dischargeAverage_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dischargeAverage_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26943;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dischargeAverage_delta_old" ON "dbrdf_dischargeAverage_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dischargeAverage_delta_old" ON "dbrdf_dischargeAverage_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dischargeAverage_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 461
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_coverArtist_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_coverArtist_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26944;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_coverArtist_delta_old" ON "dbrdf_coverArtist_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_coverArtist_delta_old" ON "dbrdf_coverArtist_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_coverArtist_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 462
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_budget_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_budget_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26945;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_budget_delta_old" ON "dbrdf_budget_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_budget_delta_old" ON "dbrdf_budget_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_budget_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 463
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_runwayDesignation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_runwayDesignation_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26946;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_runwayDesignation_delta_old" ON "dbrdf_runwayDesignation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_runwayDesignation_delta_old" ON "dbrdf_runwayDesignation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_runwayDesignation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 464
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_floodingDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_floodingDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26947;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_floodingDate_delta_old" ON "dbrdf_floodingDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_floodingDate_delta_old" ON "dbrdf_floodingDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_floodingDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 465
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceMountain_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sourceMountain_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26948;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sourceMountain_delta_old" ON "dbrdf_sourceMountain_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sourceMountain_delta_old" ON "dbrdf_sourceMountain_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceMountain_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 466
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rebuildingDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rebuildingDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26949;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rebuildingDate_delta_old" ON "dbrdf_rebuildingDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rebuildingDate_delta_old" ON "dbrdf_rebuildingDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rebuildingDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 467
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_countryWithFirstSatelliteLaunched_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_countryWithFirstSatelliteLaunched_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26950;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_countryWithFirstSatelliteLaunched_delta_old" ON "dbrdf_countryWithFirstSatelliteLaunched_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_countryWithFirstSatelliteLaunched_delta_old" ON "dbrdf_countryWithFirstSatelliteLaunched_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_countryWithFirstSatelliteLaunched_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 468
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_literaryGenre_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_literaryGenre_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26951;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_literaryGenre_delta_old" ON "dbrdf_literaryGenre_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_literaryGenre_delta_old" ON "dbrdf_literaryGenre_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_literaryGenre_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 469
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_colour_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_colour_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26952;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_colour_delta_old" ON "dbrdf_colour_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_colour_delta_old" ON "dbrdf_colour_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_colour_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 470
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_managerTitle_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_managerTitle_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26953;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_managerTitle_delta_old" ON "dbrdf_managerTitle_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_managerTitle_delta_old" ON "dbrdf_managerTitle_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_managerTitle_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 471
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26954, t0.o FROM "dbrdf_periapsis_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_periapsis_delta_old0";
        INSERT INTO "dbrdf_periapsis_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_periapsis_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_periapsis_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 472
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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