        INSERT INTO "dbrdf_populationRural_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_populationRural_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27295 AND ex.o = t0.o);


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 813
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_productionEndYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_productionEndYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27296;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_productionEndYear_delta_old" ON "dbrdf_productionEndYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_productionEndYear_delta_old" ON "dbrdf_productionEndYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_productionEndYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 814
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_department_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_department_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27297;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_department_delta_old" ON "dbrdf_department_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_department_delta_old" ON "dbrdf_department_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_department_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 815
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cityType_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cityType_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27298;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cityType_delta_old" ON "dbrdf_cityType_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_cityType_delta_old" ON "dbrdf_cityType_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cityType_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 816
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_perCapitaIncomeAsOf_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_perCapitaIncomeAsOf_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27299;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_perCapitaIncomeAsOf_delta_old" ON "dbrdf_perCapitaIncomeAsOf_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_perCapitaIncomeAsOf_delta_old" ON "dbrdf_perCapitaIncomeAsOf_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_perCapitaIncomeAsOf_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 817
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_brainInfoNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_brainInfoNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27300;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_brainInfoNumber_delta_old" ON "dbrdf_brainInfoNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_brainInfoNumber_delta_old" ON "dbrdf_brainInfoNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_brainInfoNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 818
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_isoCodeRegion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_isoCodeRegion_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27301;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_isoCodeRegion_delta_old" ON "dbrdf_isoCodeRegion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_isoCodeRegion_delta_old" ON "dbrdf_isoCodeRegion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_isoCodeRegion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 819
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaTotalRanking_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_areaTotalRanking_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27302;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_areaTotalRanking_delta_old" ON "dbrdf_areaTotalRanking_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_areaTotalRanking_delta_old" ON "dbrdf_areaTotalRanking_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaTotalRanking_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 820
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_classes_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_classes_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27303;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_classes_delta_old" ON "dbrdf_classes_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_classes_delta_old" ON "dbrdf_classes_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_classes_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 821
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 822
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_soocerLeagueSeason_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_soocerLeagueSeason_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27305;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_soocerLeagueSeason_delta_old" ON "dbrdf_soocerLeagueSeason_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_soocerLeagueSeason_delta_old" ON "dbrdf_soocerLeagueSeason_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_soocerLeagueSeason_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 823
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_wingArea_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_wingArea_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27306;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_wingArea_delta_old" ON "dbrdf_wingArea_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_wingArea_delta_old" ON "dbrdf_wingArea_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_wingArea_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 824
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_secondDriver_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_secondDriver_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27307;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_secondDriver_delta_old" ON "dbrdf_secondDriver_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_secondDriver_delta_old" ON "dbrdf_secondDriver_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_secondDriver_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 825
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfTerritories_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfTerritories_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27308;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfTerritories_delta_old" ON "dbrdf_numberOfTerritories_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfTerritories_delta_old" ON "dbrdf_numberOfTerritories_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfTerritories_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 826
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_provost_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_provost_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27309;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_provost_delta_old" ON "dbrdf_provost_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_provost_delta_old" ON "dbrdf_provost_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_provost_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 827
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_launchVehicle_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_launchVehicle_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27310;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_launchVehicle_delta_old" ON "dbrdf_launchVehicle_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_launchVehicle_delta_old" ON "dbrdf_launchVehicle_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_launchVehicle_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 828
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_species_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_species_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27311;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_species_delta_old" ON "dbrdf_species_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_species_delta_old" ON "dbrdf_species_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_species_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 829
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_zdb_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_zdb_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27312;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_zdb_delta_old" ON "dbrdf_zdb_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_zdb_delta_old" ON "dbrdf_zdb_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_zdb_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 830
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27313, t0.o FROM "dbrdf_populationDensity_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_populationDensity_delta_old1";
        INSERT INTO "dbrdf_populationDensity_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_populationDensity_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_populationDensity_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 831
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_revenue_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_revenue_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27314;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_revenue_delta_old" ON "dbrdf_revenue_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_revenue_delta_old" ON "dbrdf_revenue_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_revenue_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 832
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_reservations_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_reservations_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27315;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_reservations_delta_old" ON "dbrdf_reservations_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_reservations_delta_old" ON "dbrdf_reservations_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_reservations_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 833
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_grayPage_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_grayPage_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27316;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_grayPage_delta_old" ON "dbrdf_grayPage_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_grayPage_delta_old" ON "dbrdf_grayPage_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_grayPage_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 834
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_feastDay_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_feastDay_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27317;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_feastDay_delta_old" ON "dbrdf_feastDay_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_feastDay_delta_old" ON "dbrdf_feastDay_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_feastDay_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 835
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_isPartOfMilitaryConflict_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_isPartOfMilitaryConflict_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27318;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_isPartOfMilitaryConflict_delta_old" ON "dbrdf_isPartOfMilitaryConflict_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_isPartOfMilitaryConflict_delta_old" ON "dbrdf_isPartOfMilitaryConflict_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_isPartOfMilitaryConflict_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 836
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_partialFailedLaunches_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_partialFailedLaunches_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27319;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_partialFailedLaunches_delta_old" ON "dbrdf_partialFailedLaunches_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_partialFailedLaunches_delta_old" ON "dbrdf_partialFailedLaunches_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_partialFailedLaunches_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 837
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_callSign_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_callSign_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27320;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_callSign_delta_old" ON "dbrdf_callSign_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_callSign_delta_old" ON "dbrdf_callSign_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_callSign_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 838
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 839
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_iso6392Code_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_iso6392Code_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27322;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_iso6392Code_delta_old" ON "dbrdf_iso6392Code_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_iso6392Code_delta_old" ON "dbrdf_iso6392Code_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_iso6392Code_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 840
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_periapsis_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_periapsis_delta_old1"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27323;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_periapsis_delta_old1" ON "dbrdf_periapsis_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_periapsis_delta_old1" ON "dbrdf_periapsis_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_periapsis_delta_new1"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27323, t0.o FROM "dbrdf_periapsis_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_periapsis_delta_old1";
        INSERT INTO "dbrdf_periapsis_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_periapsis_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_periapsis_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 841
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_closingYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_closingYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27324;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_closingYear_delta_old" ON "dbrdf_closingYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_closingYear_delta_old" ON "dbrdf_closingYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_closingYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 842
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_pdb_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_pdb_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27325;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_pdb_delta_old" ON "dbrdf_pdb_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_pdb_delta_old" ON "dbrdf_pdb_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_pdb_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 843
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_poorestCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_poorestCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27326;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_poorestCountry_delta_old" ON "dbrdf_poorestCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_poorestCountry_delta_old" ON "dbrdf_poorestCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_poorestCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 844
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastFlightEndDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lastFlightEndDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27327;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lastFlightEndDate_delta_old" ON "dbrdf_lastFlightEndDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lastFlightEndDate_delta_old" ON "dbrdf_lastFlightEndDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastFlightEndDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 845
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_symbol_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_symbol_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27328;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_symbol_delta_old" ON "dbrdf_symbol_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_symbol_delta_old" ON "dbrdf_symbol_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_symbol_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 846
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_peabodyAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_peabodyAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27329;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_peabodyAward_delta_old" ON "dbrdf_peabodyAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_peabodyAward_delta_old" ON "dbrdf_peabodyAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_peabodyAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 847
    ---- DEPENDS ON: 846, 463, 143, 57, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 848
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_foundingYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_foundingYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27331;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_foundingYear_delta_old" ON "dbrdf_foundingYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_foundingYear_delta_old" ON "dbrdf_foundingYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_foundingYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 849
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_spokenIn_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_spokenIn_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27332;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_spokenIn_delta_old" ON "dbrdf_spokenIn_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_spokenIn_delta_old" ON "dbrdf_spokenIn_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_spokenIn_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 850
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nameDay_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nameDay_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27333;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nameDay_delta_old" ON "dbrdf_nameDay_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nameDay_delta_old" ON "dbrdf_nameDay_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nameDay_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 851
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftHelicopterCargo_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftHelicopterCargo_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27334;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftHelicopterCargo_delta_old" ON "dbrdf_aircraftHelicopterCargo_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftHelicopterCargo_delta_old" ON "dbrdf_aircraftHelicopterCargo_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftHelicopterCargo_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 852
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 853
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_fareZone_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_fareZone_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27336;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_fareZone_delta_old" ON "dbrdf_fareZone_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_fareZone_delta_old" ON "dbrdf_fareZone_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_fareZone_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 854
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_laurenceOlivierAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_laurenceOlivierAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27337;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_laurenceOlivierAward_delta_old" ON "dbrdf_laurenceOlivierAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_laurenceOlivierAward_delta_old" ON "dbrdf_laurenceOlivierAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_laurenceOlivierAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 855
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_region_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_region_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27338;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_region_delta_old" ON "dbrdf_region_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_region_delta_old" ON "dbrdf_region_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_region_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 856
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftInterceptor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftInterceptor_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27339;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftInterceptor_delta_old" ON "dbrdf_aircraftInterceptor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftInterceptor_delta_old" ON "dbrdf_aircraftInterceptor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftInterceptor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 857
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_goalsInNationalTeam_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_goalsInNationalTeam_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27340;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_goalsInNationalTeam_delta_old" ON "dbrdf_goalsInNationalTeam_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_goalsInNationalTeam_delta_old" ON "dbrdf_goalsInNationalTeam_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_goalsInNationalTeam_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 858
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lowestPosition_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lowestPosition_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27341;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lowestPosition_delta_old" ON "dbrdf_lowestPosition_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lowestPosition_delta_old" ON "dbrdf_lowestPosition_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lowestPosition_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 859
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceDistrict_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sourceDistrict_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27342;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sourceDistrict_delta_old" ON "dbrdf_sourceDistrict_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sourceDistrict_delta_old" ON "dbrdf_sourceDistrict_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceDistrict_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 860
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 861
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_actScore_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_actScore_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27344;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_actScore_delta_old" ON "dbrdf_actScore_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_actScore_delta_old" ON "dbrdf_actScore_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_actScore_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 862
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_port2DockedTime_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_port2DockedTime_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27345;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_port2DockedTime_delta_old0" ON "dbrdf_port2DockedTime_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_port2DockedTime_delta_old0" ON "dbrdf_port2DockedTime_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_port2DockedTime_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27345, t0.o FROM "dbrdf_port2DockedTime_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_port2DockedTime_delta_old0";
        INSERT INTO "dbrdf_port2DockedTime_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_port2DockedTime_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_port2DockedTime_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 863
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_derivative_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_derivative_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27346;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_derivative_delta_old" ON "dbrdf_derivative_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_derivative_delta_old" ON "dbrdf_derivative_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_derivative_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 864
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfCountries_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfCountries_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27347;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfCountries_delta_old" ON "dbrdf_numberOfCountries_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfCountries_delta_old" ON "dbrdf_numberOfCountries_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfCountries_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 865
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_appointer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_appointer_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27348;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_appointer_delta_old" ON "dbrdf_appointer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_appointer_delta_old" ON "dbrdf_appointer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_appointer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 866
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_officialSchoolColour_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_officialSchoolColour_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27349;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_officialSchoolColour_delta_old" ON "dbrdf_officialSchoolColour_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_officialSchoolColour_delta_old" ON "dbrdf_officialSchoolColour_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_officialSchoolColour_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 867
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_originalName_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_originalName_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27350;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_originalName_delta_old" ON "dbrdf_originalName_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_originalName_delta_old" ON "dbrdf_originalName_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_originalName_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 868
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 869
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27352, t0.o FROM "dbrdf_lunarSampleMass_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_lunarSampleMass_delta_old0";
        INSERT INTO "dbrdf_lunarSampleMass_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lunarSampleMass_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_lunarSampleMass_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 870
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_commonName_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_commonName_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27353;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_commonName_delta_old" ON "dbrdf_commonName_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_commonName_delta_old" ON "dbrdf_commonName_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_commonName_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 871
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_leftTributary_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_leftTributary_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27354;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_leftTributary_delta_old" ON "dbrdf_leftTributary_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_leftTributary_delta_old" ON "dbrdf_leftTributary_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_leftTributary_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 872
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_deputy_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_deputy_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27355;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_deputy_delta_old" ON "dbrdf_deputy_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_deputy_delta_old" ON "dbrdf_deputy_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_deputy_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 873
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 874
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 875
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_height_delta_old3"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_height_delta_old3"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27358;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_height_delta_old3" ON "dbrdf_height_delta_old3"(s, o); CREATE INDEX "IDX_1_dbrdf_height_delta_old3" ON "dbrdf_height_delta_old3"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_height_delta_new3"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 876
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_thirdCommander_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_thirdCommander_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27359;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_thirdCommander_delta_old" ON "dbrdf_thirdCommander_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_thirdCommander_delta_old" ON "dbrdf_thirdCommander_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_thirdCommander_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 877
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_humanDevelopmentIndexRankingCategory_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_humanDevelopmentIndexRankingCategory_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27360;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_humanDevelopmentIndexRankingCategory_delta_old" ON "dbrdf_humanDevelopmentIndexRankingCategory_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_humanDevelopmentIndexRankingCategory_delta_old" ON "dbrdf_humanDevelopmentIndexRankingCategory_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_humanDevelopmentIndexRankingCategory_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 878
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftHelicopterMultirole_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftHelicopterMultirole_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27361;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftHelicopterMultirole_delta_old" ON "dbrdf_aircraftHelicopterMultirole_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftHelicopterMultirole_delta_old" ON "dbrdf_aircraftHelicopterMultirole_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftHelicopterMultirole_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 879
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Sculpture_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Sculpture_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27362;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Sculpture_delta_old" ON "dbrdf_Sculpture_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Sculpture_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Sculpture_delta_old0"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Sculpture_delta_old0"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27363;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Sculpture_delta_old0" ON "dbrdf_Sculpture_delta_old0"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Sculpture_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/Sculpture$delta_new>(?X) :- <http://dbpedia.org/ontology/Sculpture$delta_old>(?X) .
        INSERT INTO "dbrdf_Sculpture_delta_new"(s) SELECT t0.s FROM "dbrdf_Sculpture_delta_old0" t0 WHERE NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27362);


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


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


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


        -- Propagate $delta_new

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

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27363 FROM "dbrdf_Sculpture_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_Sculpture_delta_old0";
        INSERT INTO "dbrdf_Sculpture_delta_old0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Sculpture_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_Sculpture_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 880
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstAirDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstAirDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27364;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstAirDate_delta_old" ON "dbrdf_firstAirDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstAirDate_delta_old" ON "dbrdf_firstAirDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstAirDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 881
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_chef_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_chef_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27365;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_chef_delta_old" ON "dbrdf_chef_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_chef_delta_old" ON "dbrdf_chef_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_chef_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 882
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_orderDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_orderDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27366;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_orderDate_delta_old" ON "dbrdf_orderDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_orderDate_delta_old" ON "dbrdf_orderDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_orderDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 883
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_targetSpaceStation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_targetSpaceStation_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27367;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_targetSpaceStation_delta_old" ON "dbrdf_targetSpaceStation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_targetSpaceStation_delta_old" ON "dbrdf_targetSpaceStation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_targetSpaceStation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 884
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_giniCoefficient_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_giniCoefficient_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27368;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_giniCoefficient_delta_old" ON "dbrdf_giniCoefficient_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_giniCoefficient_delta_old" ON "dbrdf_giniCoefficient_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_giniCoefficient_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 885
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_hsvCoordinateHue_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_hsvCoordinateHue_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27369;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_hsvCoordinateHue_delta_old" ON "dbrdf_hsvCoordinateHue_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_hsvCoordinateHue_delta_old" ON "dbrdf_hsvCoordinateHue_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_hsvCoordinateHue_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 886
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_commander_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_commander_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27370;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_commander_delta_old" ON "dbrdf_commander_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_commander_delta_old" ON "dbrdf_commander_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_commander_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 887
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_narrator_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_narrator_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27371;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_narrator_delta_old" ON "dbrdf_narrator_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_narrator_delta_old" ON "dbrdf_narrator_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_narrator_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 888
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_meanRadius_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_meanRadius_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27372;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_meanRadius_delta_old0" ON "dbrdf_meanRadius_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_meanRadius_delta_old0" ON "dbrdf_meanRadius_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_meanRadius_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/Galaxy/meanRadius$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Galaxy/meanRadius$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_meanRadius_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_meanRadius_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 = 27372 AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27372, t0.o FROM "dbrdf_meanRadius_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_meanRadius_delta_old0";
        INSERT INTO "dbrdf_meanRadius_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_meanRadius_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_meanRadius_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 889
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 890
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_openingTheme_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_openingTheme_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27374;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_openingTheme_delta_old" ON "dbrdf_openingTheme_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_openingTheme_delta_old" ON "dbrdf_openingTheme_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_openingTheme_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 891
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_routeEnd_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_routeEnd_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27375;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_routeEnd_delta_old" ON "dbrdf_routeEnd_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_routeEnd_delta_old" ON "dbrdf_routeEnd_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_routeEnd_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 892
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 893
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_birthPlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_birthPlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27377;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_birthPlace_delta_old" ON "dbrdf_birthPlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_birthPlace_delta_old" ON "dbrdf_birthPlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_birthPlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 894
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfCapitalDeputies_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfCapitalDeputies_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27378;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfCapitalDeputies_delta_old" ON "dbrdf_numberOfCapitalDeputies_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfCapitalDeputies_delta_old" ON "dbrdf_numberOfCapitalDeputies_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfCapitalDeputies_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 895
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfDoctoralStudents_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfDoctoralStudents_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27379;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfDoctoralStudents_delta_old" ON "dbrdf_numberOfDoctoralStudents_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfDoctoralStudents_delta_old" ON "dbrdf_numberOfDoctoralStudents_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfDoctoralStudents_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 896
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_distanceToCapital_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_distanceToCapital_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27380;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_distanceToCapital_delta_old" ON "dbrdf_distanceToCapital_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_distanceToCapital_delta_old" ON "dbrdf_distanceToCapital_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_distanceToCapital_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 897
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_pastor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_pastor_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27381;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_pastor_delta_old" ON "dbrdf_pastor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_pastor_delta_old" ON "dbrdf_pastor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_pastor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 898
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 899
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 900
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_explorer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_explorer_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27384;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_explorer_delta_old" ON "dbrdf_explorer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_explorer_delta_old" ON "dbrdf_explorer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_explorer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 901
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 902
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_bridgeCarries_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_bridgeCarries_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27386;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_bridgeCarries_delta_old" ON "dbrdf_bridgeCarries_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_bridgeCarries_delta_old" ON "dbrdf_bridgeCarries_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_bridgeCarries_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 903
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfSeasons_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfSeasons_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27387;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfSeasons_delta_old" ON "dbrdf_numberOfSeasons_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfSeasons_delta_old" ON "dbrdf_numberOfSeasons_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfSeasons_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 904
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_noteOnRestingPlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_noteOnRestingPlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27388;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_noteOnRestingPlace_delta_old" ON "dbrdf_noteOnRestingPlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_noteOnRestingPlace_delta_old" ON "dbrdf_noteOnRestingPlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_noteOnRestingPlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 905
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_otherAppearances_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_otherAppearances_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27389;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_otherAppearances_delta_old" ON "dbrdf_otherAppearances_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_otherAppearances_delta_old" ON "dbrdf_otherAppearances_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_otherAppearances_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 906
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfCounties_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfCounties_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27390;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfCounties_delta_old" ON "dbrdf_numberOfCounties_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfCounties_delta_old" ON "dbrdf_numberOfCounties_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfCounties_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 907
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_governmentMountain_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_governmentMountain_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27391;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_governmentMountain_delta_old" ON "dbrdf_governmentMountain_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_governmentMountain_delta_old" ON "dbrdf_governmentMountain_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_governmentMountain_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 908
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_infantMortality_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_infantMortality_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27392;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_infantMortality_delta_old" ON "dbrdf_infantMortality_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_infantMortality_delta_old" ON "dbrdf_infantMortality_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_infantMortality_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 909
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 910
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27394, t0.o FROM "dbrdf_orbitalPeriod_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_orbitalPeriod_delta_old1";
        INSERT INTO "dbrdf_orbitalPeriod_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_orbitalPeriod_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_orbitalPeriod_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 911
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaMetro_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_areaMetro_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27395;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_areaMetro_delta_old" ON "dbrdf_areaMetro_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_areaMetro_delta_old" ON "dbrdf_areaMetro_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaMetro_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 912
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_training_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_training_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27396;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_training_delta_old" ON "dbrdf_training_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_training_delta_old" ON "dbrdf_training_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_training_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 913
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_headteacher_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_headteacher_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27397;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_headteacher_delta_old" ON "dbrdf_headteacher_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_headteacher_delta_old" ON "dbrdf_headteacher_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_headteacher_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 914
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_launchDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_launchDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27398;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_launchDate_delta_old" ON "dbrdf_launchDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_launchDate_delta_old" ON "dbrdf_launchDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_launchDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 915
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaOfSearch_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_areaOfSearch_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27399;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_areaOfSearch_delta_old" ON "dbrdf_areaOfSearch_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_areaOfSearch_delta_old" ON "dbrdf_areaOfSearch_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaOfSearch_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 916
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_stationVisitDuration_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_stationVisitDuration_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27400;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_stationVisitDuration_delta_old" ON "dbrdf_stationVisitDuration_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_stationVisitDuration_delta_old" ON "dbrdf_stationVisitDuration_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_stationVisitDuration_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 917
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_homeArena_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_homeArena_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27401;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_homeArena_delta_old" ON "dbrdf_homeArena_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_homeArena_delta_old" ON "dbrdf_homeArena_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_homeArena_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 918
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_bedCount_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_bedCount_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27402;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_bedCount_delta_old" ON "dbrdf_bedCount_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_bedCount_delta_old" ON "dbrdf_bedCount_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_bedCount_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 919
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_iftaAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_iftaAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27403;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_iftaAward_delta_old" ON "dbrdf_iftaAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_iftaAward_delta_old" ON "dbrdf_iftaAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_iftaAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 920
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27404, t0.o FROM "dbrdf_meanRadius_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_meanRadius_delta_old1";
        INSERT INTO "dbrdf_meanRadius_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_meanRadius_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_meanRadius_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 921
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 922
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 923
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_otherServingLines_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_otherServingLines_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27407;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_otherServingLines_delta_old" ON "dbrdf_otherServingLines_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_otherServingLines_delta_old" ON "dbrdf_otherServingLines_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_otherServingLines_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 924
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_governmentElevation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_governmentElevation_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27408;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_governmentElevation_delta_old" ON "dbrdf_governmentElevation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_governmentElevation_delta_old" ON "dbrdf_governmentElevation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_governmentElevation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 925
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_openingFilm_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_openingFilm_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27409;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_openingFilm_delta_old" ON "dbrdf_openingFilm_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_openingFilm_delta_old" ON "dbrdf_openingFilm_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_openingFilm_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 926
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_poles_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_poles_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27410;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_poles_delta_old" ON "dbrdf_poles_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_poles_delta_old" ON "dbrdf_poles_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_poles_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 927
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lessPopulousCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lessPopulousCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27411;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lessPopulousCountry_delta_old" ON "dbrdf_lessPopulousCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lessPopulousCountry_delta_old" ON "dbrdf_lessPopulousCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lessPopulousCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 928
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_icaoLocationIdentifier_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_icaoLocationIdentifier_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27412;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_icaoLocationIdentifier_delta_old" ON "dbrdf_icaoLocationIdentifier_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_icaoLocationIdentifier_delta_old" ON "dbrdf_icaoLocationIdentifier_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_icaoLocationIdentifier_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 929
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 930
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_soocerLeaguePromoted_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_soocerLeaguePromoted_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27414;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_soocerLeaguePromoted_delta_old" ON "dbrdf_soocerLeaguePromoted_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_soocerLeaguePromoted_delta_old" ON "dbrdf_soocerLeaguePromoted_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_soocerLeaguePromoted_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 931
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectType_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_projectType_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27415;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_projectType_delta_old" ON "dbrdf_projectType_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_projectType_delta_old" ON "dbrdf_projectType_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectType_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 932
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_poleDriverTeam_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_poleDriverTeam_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27416;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_poleDriverTeam_delta_old" ON "dbrdf_poleDriverTeam_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_poleDriverTeam_delta_old" ON "dbrdf_poleDriverTeam_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_poleDriverTeam_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 933
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_closed_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_closed_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27417;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_closed_delta_old" ON "dbrdf_closed_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_closed_delta_old" ON "dbrdf_closed_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_closed_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 934
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_GovernmentAgency_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_GovernmentAgency_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27418;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_GovernmentAgency_delta_old" ON "dbrdf_GovernmentAgency_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_GovernmentAgency_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_GovernmentOrganization_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_GovernmentOrganization_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27419;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_GovernmentOrganization_delta_old" ON "dbrdf_GovernmentOrganization_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_GovernmentOrganization_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/GovernmentAgency$delta_new>(?X) :- <http://schema.org/GovernmentOrganization$delta_old>(?X) .
        INSERT INTO "dbrdf_GovernmentAgency_delta_new"(s) SELECT t0.s FROM "dbrdf_GovernmentOrganization_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27418);


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


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


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


        -- Propagate $delta_new

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

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 935
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_religiousHead_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_religiousHead_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27420;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_religiousHead_delta_old" ON "dbrdf_religiousHead_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_religiousHead_delta_old" ON "dbrdf_religiousHead_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_religiousHead_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 936
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_principalArea_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_principalArea_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27421;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_principalArea_delta_old" ON "dbrdf_principalArea_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_principalArea_delta_old" ON "dbrdf_principalArea_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_principalArea_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 937
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_finalPublicationDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_finalPublicationDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27422;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_finalPublicationDate_delta_old" ON "dbrdf_finalPublicationDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_finalPublicationDate_delta_old" ON "dbrdf_finalPublicationDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_finalPublicationDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 938
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_minimumDischarge_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_minimumDischarge_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27423;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_minimumDischarge_delta_old0" ON "dbrdf_minimumDischarge_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_minimumDischarge_delta_old0" ON "dbrdf_minimumDischarge_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_minimumDischarge_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/Stream/minimumDischarge$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Stream/minimumDischarge$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_minimumDischarge_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_minimumDischarge_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 = 27423 AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27423, t0.o FROM "dbrdf_minimumDischarge_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_minimumDischarge_delta_old0";
        INSERT INTO "dbrdf_minimumDischarge_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_minimumDischarge_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_minimumDischarge_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 939
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_leaderName_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_leaderName_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27424;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_leaderName_delta_old" ON "dbrdf_leaderName_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_leaderName_delta_old" ON "dbrdf_leaderName_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_leaderName_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 940
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 941
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_longtype_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_longtype_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27426;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_longtype_delta_old" ON "dbrdf_longtype_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_longtype_delta_old" ON "dbrdf_longtype_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_longtype_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 942
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lccn_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lccn_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27427;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lccn_delta_old" ON "dbrdf_lccn_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lccn_delta_old" ON "dbrdf_lccn_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lccn_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 943
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsSection_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_alpsSection_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27428;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_alpsSection_delta_old" ON "dbrdf_alpsSection_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_alpsSection_delta_old" ON "dbrdf_alpsSection_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsSection_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 944
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 945
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sportDiscipline_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sportDiscipline_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27430;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sportDiscipline_delta_old" ON "dbrdf_sportDiscipline_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sportDiscipline_delta_old" ON "dbrdf_sportDiscipline_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sportDiscipline_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 946
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_gaudiAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_gaudiAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27431;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_gaudiAward_delta_old" ON "dbrdf_gaudiAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_gaudiAward_delta_old" ON "dbrdf_gaudiAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_gaudiAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 947
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27432, t0.o FROM "dbrdf_discharge_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_discharge_delta_old0";
        INSERT INTO "dbrdf_discharge_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_discharge_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_discharge_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 948
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_veneratedIn_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_veneratedIn_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27433;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_veneratedIn_delta_old" ON "dbrdf_veneratedIn_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_veneratedIn_delta_old" ON "dbrdf_veneratedIn_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_veneratedIn_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 949
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 950
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberBuilt_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberBuilt_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27435;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberBuilt_delta_old" ON "dbrdf_numberBuilt_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberBuilt_delta_old" ON "dbrdf_numberBuilt_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberBuilt_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 951
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumDepth_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_maximumDepth_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27436;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_maximumDepth_delta_old" ON "dbrdf_maximumDepth_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_maximumDepth_delta_old" ON "dbrdf_maximumDepth_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumDepth_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 952
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_frozen_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_frozen_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27437;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_frozen_delta_old" ON "dbrdf_frozen_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_frozen_delta_old" ON "dbrdf_frozen_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_frozen_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 953
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_flagBearer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_flagBearer_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27438;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_flagBearer_delta_old" ON "dbrdf_flagBearer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_flagBearer_delta_old" ON "dbrdf_flagBearer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_flagBearer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 954
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_building_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_building_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27439;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_building_delta_old" ON "dbrdf_building_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_building_delta_old" ON "dbrdf_building_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_building_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 955
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_raceLength_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_raceLength_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27440;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_raceLength_delta_old" ON "dbrdf_raceLength_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_raceLength_delta_old" ON "dbrdf_raceLength_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_raceLength_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 956
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_temperature_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_temperature_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27441;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_temperature_delta_old0" ON "dbrdf_temperature_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_temperature_delta_old0" ON "dbrdf_temperature_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_temperature_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27441, t0.o FROM "dbrdf_temperature_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_temperature_delta_old0";
        INSERT INTO "dbrdf_temperature_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_temperature_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_temperature_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 957
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 958
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfMembers_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfMembers_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27443;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfMembers_delta_old" ON "dbrdf_numberOfMembers_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfMembers_delta_old" ON "dbrdf_numberOfMembers_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfMembers_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 959
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_boilingPoint_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_boilingPoint_delta_old1"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27444;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_boilingPoint_delta_old1" ON "dbrdf_boilingPoint_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_boilingPoint_delta_old1" ON "dbrdf_boilingPoint_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_boilingPoint_delta_new1"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 960
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftHelicopterUtility_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftHelicopterUtility_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27445;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftHelicopterUtility_delta_old" ON "dbrdf_aircraftHelicopterUtility_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftHelicopterUtility_delta_old" ON "dbrdf_aircraftHelicopterUtility_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftHelicopterUtility_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 961
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_originalStartPoint_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_originalStartPoint_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27446;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_originalStartPoint_delta_old" ON "dbrdf_originalStartPoint_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_originalStartPoint_delta_old" ON "dbrdf_originalStartPoint_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_originalStartPoint_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 962
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cargoFuel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cargoFuel_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27447;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cargoFuel_delta_old" ON "dbrdf_cargoFuel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_cargoFuel_delta_old" ON "dbrdf_cargoFuel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cargoFuel_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 963
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27448, t0.o FROM "dbrdf_populationUrbanDensity_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_populationUrbanDensity_delta_old0";
        INSERT INTO "dbrdf_populationUrbanDensity_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_populationUrbanDensity_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_populationUrbanDensity_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 964
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_secondTeam_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_secondTeam_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27449;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_secondTeam_delta_old" ON "dbrdf_secondTeam_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_secondTeam_delta_old" ON "dbrdf_secondTeam_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_secondTeam_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 965
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_percentageOfAreaWater_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_percentageOfAreaWater_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27450;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_percentageOfAreaWater_delta_old" ON "dbrdf_percentageOfAreaWater_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_percentageOfAreaWater_delta_old" ON "dbrdf_percentageOfAreaWater_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_percentageOfAreaWater_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 966
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_distanceToBelfast_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_distanceToBelfast_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27451;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_distanceToBelfast_delta_old" ON "dbrdf_distanceToBelfast_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_distanceToBelfast_delta_old" ON "dbrdf_distanceToBelfast_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_distanceToBelfast_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 967
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_totalMass_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_totalMass_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27452;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_totalMass_delta_old" ON "dbrdf_totalMass_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_totalMass_delta_old" ON "dbrdf_totalMass_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_totalMass_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 968
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_recordedIn_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_recordedIn_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27453;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_recordedIn_delta_old" ON "dbrdf_recordedIn_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_recordedIn_delta_old" ON "dbrdf_recordedIn_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_recordedIn_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 969
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerPartner_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_formerPartner_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27454;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_formerPartner_delta_old" ON "dbrdf_formerPartner_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_formerPartner_delta_old" ON "dbrdf_formerPartner_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerPartner_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 970
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_capitalMountain_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_capitalMountain_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27455;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_capitalMountain_delta_old" ON "dbrdf_capitalMountain_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_capitalMountain_delta_old" ON "dbrdf_capitalMountain_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_capitalMountain_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 971
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 972
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_currencyCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_currencyCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27457;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_currencyCode_delta_old" ON "dbrdf_currencyCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_currencyCode_delta_old" ON "dbrdf_currencyCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_currencyCode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 973
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfFederalDeputies_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfFederalDeputies_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27458;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfFederalDeputies_delta_old" ON "dbrdf_numberOfFederalDeputies_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfFederalDeputies_delta_old" ON "dbrdf_numberOfFederalDeputies_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfFederalDeputies_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 974
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfEmployees_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfEmployees_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27459;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfEmployees_delta_old" ON "dbrdf_numberOfEmployees_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfEmployees_delta_old" ON "dbrdf_numberOfEmployees_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfEmployees_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 975
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 976
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_memberOfParliament_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_memberOfParliament_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27461;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_memberOfParliament_delta_old" ON "dbrdf_memberOfParliament_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_memberOfParliament_delta_old" ON "dbrdf_memberOfParliament_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_memberOfParliament_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 977
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27462, t0.o FROM "dbrdf_meanTemperature_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_meanTemperature_delta_old1";
        INSERT INTO "dbrdf_meanTemperature_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_meanTemperature_delta_new1" t0;
