        TRUNCATE TABLE "dbrdf_meanTemperature_delta_new1";

    END LOOP;

    -- END Recursive rules

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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27463, 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 979
    ---- DEPENDS ON: 978, 475, 58, 19, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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


        -- Propagate $delta_new

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


        -- Propagate $delta_new

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


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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


        -- Propagate $delta_new

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


        -- Propagate $delta_new

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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27471, 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 987
    ---- 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 = 27472;
    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 = 27472);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27472 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 988
    ---- 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 = 27473;
    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 = 27473 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 = 27473 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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


        -- Propagate $delta_new

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


        -- Propagate $delta_new

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


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_beatifiedPlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_beatifiedPlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27478;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_beatifiedPlace_delta_old" ON "dbrdf_beatifiedPlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_beatifiedPlace_delta_old" ON "dbrdf_beatifiedPlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_beatifiedPlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 994
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_waistSize_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_waistSize_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27479;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_waistSize_delta_old" ON "dbrdf_waistSize_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_waistSize_delta_old" ON "dbrdf_waistSize_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_waistSize_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 995
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerCallsign_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_formerCallsign_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27480;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_formerCallsign_delta_old" ON "dbrdf_formerCallsign_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_formerCallsign_delta_old" ON "dbrdf_formerCallsign_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerCallsign_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 996
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_previousEvent_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_previousEvent_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27481;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_previousEvent_delta_old" ON "dbrdf_previousEvent_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_previousEvent_delta_old" ON "dbrdf_previousEvent_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_previousEvent_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 997
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_headquarter_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_headquarter_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27482;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_headquarter_delta_old" ON "dbrdf_headquarter_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_headquarter_delta_old" ON "dbrdf_headquarter_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_headquarter_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 998
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastSeason_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lastSeason_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27485;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lastSeason_delta_old" ON "dbrdf_lastSeason_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lastSeason_delta_old" ON "dbrdf_lastSeason_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastSeason_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1001
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dockedTime_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dockedTime_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27486;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dockedTime_delta_old" ON "dbrdf_dockedTime_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dockedTime_delta_old" ON "dbrdf_dockedTime_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dockedTime_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_debut_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_debut_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27488;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_debut_delta_old" ON "dbrdf_debut_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_debut_delta_old" ON "dbrdf_debut_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_debut_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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


        -- Propagate $delta_new

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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27490, 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 1006
    ---- 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 = 27491;
    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 = 27491);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27491 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 1007
    ---- DEPENDS ON: 18, 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, 27492 FROM "__triples" t0 WHERE t0.p = 26499 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27492);
    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 = 27492;
    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 = 27492);


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_canton_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_canton_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27493;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_canton_delta_old" ON "dbrdf_canton_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_canton_delta_old" ON "dbrdf_canton_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_canton_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_relatedMeanOfTransportation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_relatedMeanOfTransportation_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27495;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_relatedMeanOfTransportation_delta_old" ON "dbrdf_relatedMeanOfTransportation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_relatedMeanOfTransportation_delta_old" ON "dbrdf_relatedMeanOfTransportation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_relatedMeanOfTransportation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1011
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_river_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_river_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27496;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_river_delta_old" ON "dbrdf_river_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_river_delta_old" ON "dbrdf_river_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_river_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27497, 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 1013
    ---- 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 = 27498;
    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 = 27498);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27498 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 1014
    ---- 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 = 27499;
    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 = 27499 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 = 27499 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_yearOfConstruction_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_yearOfConstruction_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27500;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_yearOfConstruction_delta_old" ON "dbrdf_yearOfConstruction_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_yearOfConstruction_delta_old" ON "dbrdf_yearOfConstruction_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_yearOfConstruction_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1016
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_metropolitanBorough_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_metropolitanBorough_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27501;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_metropolitanBorough_delta_old" ON "dbrdf_metropolitanBorough_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_metropolitanBorough_delta_old" ON "dbrdf_metropolitanBorough_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_metropolitanBorough_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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


        -- Propagate $delta_new

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


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_shipLaunch_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_shipLaunch_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27504;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_shipLaunch_delta_old" ON "dbrdf_shipLaunch_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_shipLaunch_delta_old" ON "dbrdf_shipLaunch_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_shipLaunch_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_doctoralStudent_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_doctoralStudent_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27506;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_doctoralStudent_delta_old" ON "dbrdf_doctoralStudent_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_doctoralStudent_delta_old" ON "dbrdf_doctoralStudent_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_doctoralStudent_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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


        -- Propagate $delta_new

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


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_appearancesInLeague_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_appearancesInLeague_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27509;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_appearancesInLeague_delta_old" ON "dbrdf_appearancesInLeague_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_appearancesInLeague_delta_old" ON "dbrdf_appearancesInLeague_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_appearancesInLeague_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstFlight_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstFlight_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27511;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstFlight_delta_old" ON "dbrdf_firstFlight_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstFlight_delta_old" ON "dbrdf_firstFlight_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstFlight_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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


        -- Propagate $delta_new

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


        -- Propagate $delta_new

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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27514, 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 1030
    ---- 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 = 27515;
    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 = 27515);


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_municipalityCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_municipalityCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27516;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_municipalityCode_delta_old" ON "dbrdf_municipalityCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_municipalityCode_delta_old" ON "dbrdf_municipalityCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_municipalityCode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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


        -- Propagate $delta_new

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


        -- Propagate $delta_new

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


        -- Propagate $delta_new

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


        -- Propagate $delta_new

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


        -- Propagate $delta_new

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


        -- Propagate $delta_new

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


        -- Propagate $delta_new

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


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_fileSize_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_fileSize_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27525;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_fileSize_delta_old0" ON "dbrdf_fileSize_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_fileSize_delta_old0" ON "dbrdf_fileSize_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_fileSize_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/fileSize$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/fileSize$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_fileSize_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_fileSize_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 = 27525 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_new0"(s, o) SELECT t0.s, t1.o FROM "dbrdf_fileSize_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 = 27525 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27525, t0.o FROM "dbrdf_fileSize_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_fileSize_delta_old0";
        INSERT INTO "dbrdf_fileSize_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_fileSize_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_fileSize_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1041
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mouthRegion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mouthRegion_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27526;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mouthRegion_delta_old" ON "dbrdf_mouthRegion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mouthRegion_delta_old" ON "dbrdf_mouthRegion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mouthRegion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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


        -- Propagate $delta_new

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


        -- Propagate $delta_new

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


        -- Propagate $delta_new

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


        -- Propagate $delta_new

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


        -- Propagate $delta_new

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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27532, 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 1048
    ---- 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 = 27533;
    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/meltingPoint$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/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 = 27533 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_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 = 27533 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_shareDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_shareDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27534;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_shareDate_delta_old" ON "dbrdf_shareDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_shareDate_delta_old" ON "dbrdf_shareDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_shareDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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


        -- Propagate $delta_new

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


        -- Propagate $delta_new

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


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_serviceStartYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_serviceStartYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27538;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_serviceStartYear_delta_old" ON "dbrdf_serviceStartYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_serviceStartYear_delta_old" ON "dbrdf_serviceStartYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_serviceStartYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1054
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_assets_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_assets_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27539;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_assets_delta_old" ON "dbrdf_assets_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_assets_delta_old" ON "dbrdf_assets_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_assets_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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


        -- Propagate $delta_new

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


        -- Propagate $delta_new

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


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_meltingPoint_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_meltingPoint_delta_old1"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27543;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_meltingPoint_delta_old1" ON "dbrdf_meltingPoint_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_meltingPoint_delta_old1" ON "dbrdf_meltingPoint_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_meltingPoint_delta_new1"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27543, t0.o FROM "dbrdf_meltingPoint_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_meltingPoint_delta_old1";
        INSERT INTO "dbrdf_meltingPoint_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_meltingPoint_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_meltingPoint_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1059
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_decommissioningDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_decommissioningDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27544;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_decommissioningDate_delta_old" ON "dbrdf_decommissioningDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_decommissioningDate_delta_old" ON "dbrdf_decommissioningDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_decommissioningDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27545, 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 1061
    ---- 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 = 27546;
    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 = 27546);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27546 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 1062
    ---- 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 = 27547;
    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 = 27547 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 = 27547 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27547, 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 1063
    ---- 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 = 27548;
    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 = 27548);


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_relative_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_relative_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27549;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_relative_delta_old" ON "dbrdf_relative_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_relative_delta_old" ON "dbrdf_relative_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_relative_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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


        -- Propagate $delta_new

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


        -- Propagate $delta_new

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


        -- Propagate $delta_new

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


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_choreographer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_choreographer_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27554;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_choreographer_delta_old" ON "dbrdf_choreographer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_choreographer_delta_old" ON "dbrdf_choreographer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_choreographer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1070
    ---- 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 = 27555;
    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 = 27555);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27555 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 1071
    ---- 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 = 27556;
    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 = 27556 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 = 27556 AND ex.o = t1.o);


        -- Propagate $delta_new

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


        -- Propagate $delta_new

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


        -- Propagate $delta_new

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


        -- Propagate $delta_new

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


        -- Propagate $delta_new

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


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_isil_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_isil_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27562;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_isil_delta_old" ON "dbrdf_isil_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_isil_delta_old" ON "dbrdf_isil_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_isil_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1078
    ---- DEPENDS ON: 1077, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Library>(?X) :- <http://dbpedia.org/ontology/isil>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27564 FROM "__triples" t0 WHERE t0.p = 27562 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27564);
    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_Library_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Library_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27563;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Library_delta_old" ON "dbrdf_Library_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Library_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Library_delta_old0"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Library_delta_old0"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27564;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Library_delta_old0" ON "dbrdf_Library_delta_old0"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Library_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/Library$delta_new>(?X) :- <http://dbpedia.org/ontology/Library$delta_old>(?X) .
        INSERT INTO "dbrdf_Library_delta_new"(s) SELECT t0.s FROM "dbrdf_Library_delta_old0" t0 WHERE NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27563);


        -- <http://schema.org/Library$delta_new>(?Y) :- <http://schema.org/Library$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Library_delta_new"(s) SELECT t1.o FROM "dbrdf_Library_delta_old" t0, "__triples" t1 WHERE 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 = 27563);


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


        -- <http://dbpedia.org/ontology/Library$delta_new>(?Y) :- <http://dbpedia.org/ontology/Library$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Library_delta_new0"(s) SELECT t1.o FROM "dbrdf_Library_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 = 27564);


        -- Propagate $delta_new

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

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27564 FROM "dbrdf_Library_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_Library_delta_old0";
        INSERT INTO "dbrdf_Library_delta_old0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Library_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_Library_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1079
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_inchi_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_inchi_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27565;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_inchi_delta_old" ON "dbrdf_inchi_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_inchi_delta_old" ON "dbrdf_inchi_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_inchi_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1080
    ---- DEPENDS ON: 1079, 414, 149, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

    -- [Rule] <http://dbpedia.org/ontology/ChemicalCompound>(?X) :- <http://dbpedia.org/ontology/inn>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27566 FROM "__triples" t0 WHERE t0.p = 26631 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27566);
    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_ChemicalCompound_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ChemicalCompound_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27566;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ChemicalCompound_delta_old" ON "dbrdf_ChemicalCompound_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ChemicalCompound_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/ChemicalCompound$delta_new>(?Y) :- <http://dbpedia.org/ontology/ChemicalCompound$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_ChemicalCompound_delta_new"(s) SELECT t1.o FROM "dbrdf_ChemicalCompound_delta_old" t0, "__triples" t1 WHERE 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 = 27566);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1081
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_architectualBureau_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_architectualBureau_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27567;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_architectualBureau_delta_old" ON "dbrdf_architectualBureau_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_architectualBureau_delta_old" ON "dbrdf_architectualBureau_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_architectualBureau_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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


        -- Propagate $delta_new

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

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/ProtectedArea>(?X) :- <http://dbpedia.org/ontology/iucnCategory>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27571 FROM "__triples" t0 WHERE t0.p = 26824 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27571);
    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_ProtectedArea_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ProtectedArea_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27571;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ProtectedArea_delta_old" ON "dbrdf_ProtectedArea_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ProtectedArea_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/ProtectedArea$delta_new>(?Y) :- <http://dbpedia.org/ontology/ProtectedArea$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_ProtectedArea_delta_new"(s) SELECT t1.o FROM "dbrdf_ProtectedArea_delta_old" t0, "__triples" t1 WHERE 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 = 27571);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dorlandsPrefix_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dorlandsPrefix_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27573;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dorlandsPrefix_delta_old" ON "dbrdf_dorlandsPrefix_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dorlandsPrefix_delta_old" ON "dbrdf_dorlandsPrefix_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dorlandsPrefix_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1088
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectKeyword_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_projectKeyword_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27574;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_projectKeyword_delta_old" ON "dbrdf_projectKeyword_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_projectKeyword_delta_old" ON "dbrdf_projectKeyword_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectKeyword_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1089
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1090
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sheading_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sheading_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27576;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sheading_delta_old" ON "dbrdf_sheading_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sheading_delta_old" ON "dbrdf_sheading_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sheading_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1091
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_vicePresident_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_vicePresident_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27577;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_vicePresident_delta_old" ON "dbrdf_vicePresident_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_vicePresident_delta_old" ON "dbrdf_vicePresident_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_vicePresident_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1092
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1093
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1094
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_digitalChannel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_digitalChannel_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27580;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_digitalChannel_delta_old" ON "dbrdf_digitalChannel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_digitalChannel_delta_old" ON "dbrdf_digitalChannel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_digitalChannel_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1095
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_meshId_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_meshId_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27581;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_meshId_delta_old" ON "dbrdf_meshId_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_meshId_delta_old" ON "dbrdf_meshId_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_meshId_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1096
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_muteCharacterInPlay_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_muteCharacterInPlay_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27582;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_muteCharacterInPlay_delta_old" ON "dbrdf_muteCharacterInPlay_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_muteCharacterInPlay_delta_old" ON "dbrdf_muteCharacterInPlay_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_muteCharacterInPlay_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1097
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationTotalReference_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_populationTotalReference_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27583;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_populationTotalReference_delta_old" ON "dbrdf_populationTotalReference_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_populationTotalReference_delta_old" ON "dbrdf_populationTotalReference_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationTotalReference_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1098
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1099
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_voice_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_voice_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27585;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_voice_delta_old" ON "dbrdf_voice_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_voice_delta_old" ON "dbrdf_voice_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_voice_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1100
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_plays_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_plays_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27586;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_plays_delta_old" ON "dbrdf_plays_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_plays_delta_old" ON "dbrdf_plays_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_plays_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1101
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_functionEndDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_functionEndDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27587;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_functionEndDate_delta_old" ON "dbrdf_functionEndDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_functionEndDate_delta_old" ON "dbrdf_functionEndDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_functionEndDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1102
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_heightAboveAverageTerrain_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_heightAboveAverageTerrain_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27588;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_heightAboveAverageTerrain_delta_old" ON "dbrdf_heightAboveAverageTerrain_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_heightAboveAverageTerrain_delta_old" ON "dbrdf_heightAboveAverageTerrain_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_heightAboveAverageTerrain_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1103
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceConfluenceElevation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sourceConfluenceElevation_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27589;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sourceConfluenceElevation_delta_old" ON "dbrdf_sourceConfluenceElevation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sourceConfluenceElevation_delta_old" ON "dbrdf_sourceConfluenceElevation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceConfluenceElevation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1104
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_totalPopulation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_totalPopulation_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27590;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_totalPopulation_delta_old" ON "dbrdf_totalPopulation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_totalPopulation_delta_old" ON "dbrdf_totalPopulation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_totalPopulation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1105
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lieutenancyArea_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lieutenancyArea_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27591;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lieutenancyArea_delta_old" ON "dbrdf_lieutenancyArea_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lieutenancyArea_delta_old" ON "dbrdf_lieutenancyArea_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lieutenancyArea_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1106
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27592, t0.o FROM "dbrdf_cylinderBore_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_cylinderBore_delta_old0";
        INSERT INTO "dbrdf_cylinderBore_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cylinderBore_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_cylinderBore_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1107
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1108
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_currentStatus_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_currentStatus_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27594;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_currentStatus_delta_old" ON "dbrdf_currentStatus_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_currentStatus_delta_old" ON "dbrdf_currentStatus_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_currentStatus_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1109
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_broadcastRepeater_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_broadcastRepeater_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27595;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_broadcastRepeater_delta_old" ON "dbrdf_broadcastRepeater_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_broadcastRepeater_delta_old" ON "dbrdf_broadcastRepeater_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_broadcastRepeater_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1110
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_popularVote_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_popularVote_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27596;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_popularVote_delta_old" ON "dbrdf_popularVote_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_popularVote_delta_old" ON "dbrdf_popularVote_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_popularVote_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1111
    ---- DEPENDS ON: 1110, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Election>(?X) :- <http://dbpedia.org/ontology/popularVote>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27597 FROM "__triples" t0 WHERE t0.p = 27596 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27597);
    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_Election_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Election_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27597;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Election_delta_old" ON "dbrdf_Election_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Election_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/Election$delta_new>(?Y) :- <http://dbpedia.org/ontology/Election$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Election_delta_new"(s) SELECT t1.o FROM "dbrdf_Election_delta_old" t0, "__triples" t1 WHERE 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 = 27597);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1112
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_olympicOathSwornByJudge_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_olympicOathSwornByJudge_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27598;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_olympicOathSwornByJudge_delta_old" ON "dbrdf_olympicOathSwornByJudge_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_olympicOathSwornByJudge_delta_old" ON "dbrdf_olympicOathSwornByJudge_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_olympicOathSwornByJudge_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1113
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_runtime_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_runtime_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27599;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_runtime_delta_old" ON "dbrdf_runtime_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_runtime_delta_old" ON "dbrdf_runtime_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_runtime_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1114
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_podiums_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_podiums_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27600;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_podiums_delta_old" ON "dbrdf_podiums_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_podiums_delta_old" ON "dbrdf_podiums_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_podiums_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1115
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_stylisticOrigin_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_stylisticOrigin_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27601;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_stylisticOrigin_delta_old" ON "dbrdf_stylisticOrigin_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_stylisticOrigin_delta_old" ON "dbrdf_stylisticOrigin_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_stylisticOrigin_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1116
    ---- DEPENDS ON: 1115, 863, 773, 459, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1117
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_billed_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_billed_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27603;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_billed_delta_old" ON "dbrdf_billed_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_billed_delta_old" ON "dbrdf_billed_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_billed_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1118
    ---- DEPENDS ON: 1117, 1003, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- [Rule] <http://dbpedia.org/ontology/Wrestler>(?X) :- <http://dbpedia.org/ontology/billed>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27604 FROM "__triples" t0 WHERE t0.p = 27603 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27604);
    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_Wrestler_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Wrestler_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27604;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Wrestler_delta_old" ON "dbrdf_Wrestler_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Wrestler_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/Wrestler$delta_new>(?Y) :- <http://dbpedia.org/ontology/Wrestler$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Wrestler_delta_new"(s) SELECT t1.o FROM "dbrdf_Wrestler_delta_old" t0, "__triples" t1 WHERE 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 = 27604);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1119
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_managingEditor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_managingEditor_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27605;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_managingEditor_delta_old" ON "dbrdf_managingEditor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_managingEditor_delta_old" ON "dbrdf_managingEditor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_managingEditor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1120
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mass_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mass_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27606;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mass_delta_old0" ON "dbrdf_mass_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_mass_delta_old0" ON "dbrdf_mass_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mass_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27606, t0.o FROM "dbrdf_mass_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_mass_delta_old0";
        INSERT INTO "dbrdf_mass_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_mass_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_mass_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1121
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_countryWithFirstSatellite_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_countryWithFirstSatellite_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27607;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_countryWithFirstSatellite_delta_old" ON "dbrdf_countryWithFirstSatellite_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_countryWithFirstSatellite_delta_old" ON "dbrdf_countryWithFirstSatellite_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_countryWithFirstSatellite_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1122
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cmykCoordinateCyanic_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cmykCoordinateCyanic_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27608;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cmykCoordinateCyanic_delta_old" ON "dbrdf_cmykCoordinateCyanic_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_cmykCoordinateCyanic_delta_old" ON "dbrdf_cmykCoordinateCyanic_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cmykCoordinateCyanic_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1123
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_schoolNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_schoolNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27609;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_schoolNumber_delta_old" ON "dbrdf_schoolNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_schoolNumber_delta_old" ON "dbrdf_schoolNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_schoolNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1124
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_decideDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_decideDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27610;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_decideDate_delta_old" ON "dbrdf_decideDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_decideDate_delta_old" ON "dbrdf_decideDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_decideDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1125
    ---- DEPENDS ON: 1124, 52, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- [Rule] <http://dbpedia.org/ontology/SupremeCourtOfTheUnitedStatesCase>(?X) :- <http://dbpedia.org/ontology/argueDate>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27611 FROM "__triples" t0 WHERE t0.p = 26534 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27611);
    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_SupremeCourtOfTheUnitedStatesCase_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SupremeCourtOfTheUnitedStatesCase_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27611;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SupremeCourtOfTheUnitedStatesCase_delta_old" ON "dbrdf_SupremeCourtOfTheUnitedStatesCase_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SupremeCourtOfTheUnitedStatesCase_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/SupremeCourtOfTheUnitedStatesCase$delta_new>(?Y) :- <http://dbpedia.org/ontology/SupremeCourtOfTheUnitedStatesCase$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_SupremeCourtOfTheUnitedStatesCase_delta_new"(s) SELECT t1.o FROM "dbrdf_SupremeCourtOfTheUnitedStatesCase_delta_old" t0, "__triples" t1 WHERE 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 = 27611);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1126
    ---- DEPENDS ON: 1125, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/LegalCase>(?X) :- <http://dbpedia.org/ontology/SupremeCourtOfTheUnitedStatesCase>(?X) .
    INSERT INTO "__triples"(s, p, o) SELECT t0.s, 2, 27612 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27611 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27612);
    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_LegalCase_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_LegalCase_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27612;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_LegalCase_delta_old" ON "dbrdf_LegalCase_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_LegalCase_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/LegalCase$delta_new>(?Y) :- <http://dbpedia.org/ontology/LegalCase$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_LegalCase_delta_new"(s) SELECT t1.o FROM "dbrdf_LegalCase_delta_old" t0, "__triples" t1 WHERE 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 = 27612);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1127
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_creationYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_creationYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27613;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_creationYear_delta_old" ON "dbrdf_creationYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_creationYear_delta_old" ON "dbrdf_creationYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_creationYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1128
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nextMission_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nextMission_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27614;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nextMission_delta_old" ON "dbrdf_nextMission_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nextMission_delta_old" ON "dbrdf_nextMission_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nextMission_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1129
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_head_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_head_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27615;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_head_delta_old" ON "dbrdf_head_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_head_delta_old" ON "dbrdf_head_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_head_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1130
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1131
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_coExecutiveProducer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_coExecutiveProducer_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27617;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_coExecutiveProducer_delta_old" ON "dbrdf_coExecutiveProducer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_coExecutiveProducer_delta_old" ON "dbrdf_coExecutiveProducer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_coExecutiveProducer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1132
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumBoatLength_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_maximumBoatLength_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27618;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_maximumBoatLength_delta_old" ON "dbrdf_maximumBoatLength_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_maximumBoatLength_delta_old" ON "dbrdf_maximumBoatLength_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumBoatLength_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1133
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_pistonStroke_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_pistonStroke_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27619;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_pistonStroke_delta_old0" ON "dbrdf_pistonStroke_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_pistonStroke_delta_old0" ON "dbrdf_pistonStroke_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_pistonStroke_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27619, t0.o FROM "dbrdf_pistonStroke_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_pistonStroke_delta_old0";
        INSERT INTO "dbrdf_pistonStroke_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_pistonStroke_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_pistonStroke_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1134
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27620, t0.o FROM "dbrdf_originalMaximumBoatBeam_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_originalMaximumBoatBeam_delta_old0";
        INSERT INTO "dbrdf_originalMaximumBoatBeam_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_originalMaximumBoatBeam_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_originalMaximumBoatBeam_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1135
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_broadcastStationClass_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_broadcastStationClass_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27621;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_broadcastStationClass_delta_old" ON "dbrdf_broadcastStationClass_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_broadcastStationClass_delta_old" ON "dbrdf_broadcastStationClass_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_broadcastStationClass_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1136
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfBronzeMedalsWon_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfBronzeMedalsWon_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27622;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfBronzeMedalsWon_delta_old" ON "dbrdf_numberOfBronzeMedalsWon_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfBronzeMedalsWon_delta_old" ON "dbrdf_numberOfBronzeMedalsWon_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfBronzeMedalsWon_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1137
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_summerTemperature_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_summerTemperature_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27623;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_summerTemperature_delta_old" ON "dbrdf_summerTemperature_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_summerTemperature_delta_old" ON "dbrdf_summerTemperature_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_summerTemperature_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1138
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectStartDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_projectStartDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27624;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_projectStartDate_delta_old" ON "dbrdf_projectStartDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_projectStartDate_delta_old" ON "dbrdf_projectStartDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectStartDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1139
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstGame_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstGame_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27625;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstGame_delta_old" ON "dbrdf_firstGame_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstGame_delta_old" ON "dbrdf_firstGame_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstGame_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1140
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstPublicationDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstPublicationDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27626;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstPublicationDate_delta_old" ON "dbrdf_firstPublicationDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstPublicationDate_delta_old" ON "dbrdf_firstPublicationDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstPublicationDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1141
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_supplies_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_supplies_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27627;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_supplies_delta_old" ON "dbrdf_supplies_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_supplies_delta_old" ON "dbrdf_supplies_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_supplies_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1142
    ---- DEPENDS ON: 1141, 922, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- [Rule] <http://dbpedia.org/ontology/Artery>(?X) :- <http://dbpedia.org/ontology/supplies>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27628 FROM "__triples" t0 WHERE t0.p = 27627 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27628);
    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_Artery_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Artery_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27628;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Artery_delta_old" ON "dbrdf_Artery_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Artery_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/Artery$delta_new>(?Y) :- <http://dbpedia.org/ontology/Artery$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Artery_delta_new"(s) SELECT t1.o FROM "dbrdf_Artery_delta_old" t0, "__triples" t1 WHERE 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 = 27628);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1143
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

