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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_endYearOfInsertion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_endYearOfInsertion_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_endYearOfInsertion" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_endYearOfInsertion" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_endYearOfInsertion" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Congressman_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Congressman_delta_old"(s) SELECT t0.s FROM "dbrdf_Congressman" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Congressman_delta_old" ON "dbrdf_Congressman_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Congressman_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Congressman$delta_new>(?Y) :- <http://dbpedia.org/ontology/Congressman$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Congressman_delta_new"(s) SELECT t1.o FROM "dbrdf_Congressman_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Congressman" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Congressman"(s) SELECT DISTINCT t0.s FROM "dbrdf_Congressman_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Congressman_delta_old";
        INSERT INTO "dbrdf_Congressman_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Congressman_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Congressman_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_area_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_area_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_area" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_area_delta_old" ON "dbrdf_area_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_area_delta_old" ON "dbrdf_area_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_area_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Convention_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Convention_delta_old"(s) SELECT t0.s FROM "dbrdf_Convention" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Convention_delta_old" ON "dbrdf_Convention_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Convention_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Convention$delta_new>(?Y) :- <http://dbpedia.org/ontology/Convention$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Convention_delta_new"(s) SELECT t1.o FROM "dbrdf_Convention_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Convention" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Convention"(s) SELECT DISTINCT t0.s FROM "dbrdf_Convention_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Convention_delta_old";
        INSERT INTO "dbrdf_Convention_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Convention_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Convention_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_orbitalPeriod_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_orbitalPeriod_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_orbitalPeriod0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_orbitalPeriod_delta_old0" ON "dbrdf_orbitalPeriod_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_orbitalPeriod_delta_old0" ON "dbrdf_orbitalPeriod_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_orbitalPeriod_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/orbitalPeriod$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/orbitalPeriod$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_orbitalPeriod_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_orbitalPeriod_delta_old0" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_orbitalPeriod0" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/orbitalPeriod$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/orbitalPeriod$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_orbitalPeriod_delta_new0"(s, o) SELECT t0.s, t1.o FROM "dbrdf_orbitalPeriod_delta_old0" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_orbitalPeriod0" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_orbitalPeriod0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_orbitalPeriod_delta_new0" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_orbitalPeriod_delta_old0";
        INSERT INTO "dbrdf_orbitalPeriod_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_orbitalPeriod_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_orbitalPeriod_delta_new0";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfCompetitors_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfCompetitors_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfCompetitors" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_numberOfCompetitors" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_numberOfCompetitors" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 331
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Continent_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Continent_delta_old"(s) SELECT t0.s FROM "dbrdf_Continent" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Continent_delta_old" ON "dbrdf_Continent_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Continent_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Continent_delta_old0"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Continent_delta_old0"(s) SELECT t0.s FROM "dbrdf_Continent0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Continent_delta_old0" ON "dbrdf_Continent_delta_old0"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Continent_delta_new0"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- <http://schema.org/Continent$delta_new>(?Y) :- <http://schema.org/Continent$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Continent_delta_new"(s) SELECT t1.o FROM "dbrdf_Continent_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Continent" ex WHERE ex.s = t1.o);


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


        -- <http://dbpedia.org/ontology/Continent$delta_new>(?Y) :- <http://dbpedia.org/ontology/Continent$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Continent_delta_new0"(s) SELECT t1.o FROM "dbrdf_Continent_delta_old0" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Continent0" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Continent"(s) SELECT DISTINCT t0.s FROM "dbrdf_Continent_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Continent_delta_old";
        INSERT INTO "dbrdf_Continent_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Continent_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Continent_delta_new";

        INSERT INTO "dbrdf_Continent0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Continent_delta_new0" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Continent_delta_old0";
        INSERT INTO "dbrdf_Continent_delta_old0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Continent_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_Continent_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 332
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_TennisLeague_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_TennisLeague_delta_old"(s) SELECT t0.s FROM "dbrdf_TennisLeague" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_TennisLeague_delta_old" ON "dbrdf_TennisLeague_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_TennisLeague_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/TennisLeague$delta_new>(?Y) :- <http://dbpedia.org/ontology/TennisLeague$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_TennisLeague_delta_new"(s) SELECT t1.o FROM "dbrdf_TennisLeague_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_TennisLeague" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_TennisLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_TennisLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_TennisLeague_delta_old";
        INSERT INTO "dbrdf_TennisLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_TennisLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_TennisLeague_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_length_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_length_delta_old1"(s, o) SELECT t0.s, t0.o FROM "dbrdf_length1" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_length_delta_old1" ON "dbrdf_length_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_length_delta_old1" ON "dbrdf_length_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_length_delta_new1"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Weapon/length$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Weapon/length$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_length_delta_new1"(s, o) SELECT t1.o, t0.o FROM "dbrdf_length_delta_old1" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_length1" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/Weapon/length$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/Weapon/length$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_length_delta_new1"(s, o) SELECT t0.s, t1.o FROM "dbrdf_length_delta_old1" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_length1" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_length1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_length_delta_new1" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_length_delta_old1";
        INSERT INTO "dbrdf_length_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_length_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_length_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 335
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 336
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationUrbanDensity_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_populationUrbanDensity_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_populationUrbanDensity" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_populationUrbanDensity_delta_old" ON "dbrdf_populationUrbanDensity_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_populationUrbanDensity_delta_old" ON "dbrdf_populationUrbanDensity_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationUrbanDensity_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_GaelicGamesPlayer_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_GaelicGamesPlayer_delta_old"(s) SELECT t0.s FROM "dbrdf_GaelicGamesPlayer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_GaelicGamesPlayer_delta_old" ON "dbrdf_GaelicGamesPlayer_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_GaelicGamesPlayer_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/GaelicGamesPlayer$delta_new>(?Y) :- <http://dbpedia.org/ontology/GaelicGamesPlayer$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_GaelicGamesPlayer_delta_new"(s) SELECT t1.o FROM "dbrdf_GaelicGamesPlayer_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_GaelicGamesPlayer" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_GaelicGamesPlayer"(s) SELECT DISTINCT t0.s FROM "dbrdf_GaelicGamesPlayer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_GaelicGamesPlayer_delta_old";
        INSERT INTO "dbrdf_GaelicGamesPlayer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_GaelicGamesPlayer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_GaelicGamesPlayer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 342
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 343
    ---- DEPENDS ON: 40, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Priest>(?X) :- <http://dbpedia.org/ontology/ordination>(?X,?X1) .
    INSERT INTO "dbrdf_Priest"(s) SELECT DISTINCT t0.s FROM "dbrdf_ordination" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Priest" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Priest_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Priest_delta_old"(s) SELECT t0.s FROM "dbrdf_Priest" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Priest_delta_old" ON "dbrdf_Priest_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Priest_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Priest$delta_new>(?Y) :- <http://dbpedia.org/ontology/Priest$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Priest_delta_new"(s) SELECT t1.o FROM "dbrdf_Priest_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Priest" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Priest"(s) SELECT DISTINCT t0.s FROM "dbrdf_Priest_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Priest_delta_old";
        INSERT INTO "dbrdf_Priest_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Priest_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Priest_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Town_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Town_delta_old"(s) SELECT t0.s FROM "dbrdf_Town" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Town_delta_old" ON "dbrdf_Town_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Town_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Town$delta_new>(?Y) :- <http://dbpedia.org/ontology/Town$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Town_delta_new"(s) SELECT t1.o FROM "dbrdf_Town_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Town" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Town"(s) SELECT DISTINCT t0.s FROM "dbrdf_Town_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Town_delta_old";
        INSERT INTO "dbrdf_Town_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Town_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Town_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 346
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 347
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 348
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 349
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_PaintballLeague_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_PaintballLeague_delta_old"(s) SELECT t0.s FROM "dbrdf_PaintballLeague" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_PaintballLeague_delta_old" ON "dbrdf_PaintballLeague_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_PaintballLeague_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/PaintballLeague$delta_new>(?Y) :- <http://dbpedia.org/ontology/PaintballLeague$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_PaintballLeague_delta_new"(s) SELECT t1.o FROM "dbrdf_PaintballLeague_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_PaintballLeague" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_PaintballLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_PaintballLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_PaintballLeague_delta_old";
        INSERT INTO "dbrdf_PaintballLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_PaintballLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_PaintballLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 351
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 352
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_volume_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_volume_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_volume0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_volume_delta_old0" ON "dbrdf_volume_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_volume_delta_old0" ON "dbrdf_volume_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_volume_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/SpaceStation/volume$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/SpaceStation/volume$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_volume_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_volume_delta_old0" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_volume0" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/SpaceStation/volume$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/SpaceStation/volume$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_volume_delta_new0"(s, o) SELECT t0.s, t1.o FROM "dbrdf_volume_delta_old0" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_volume0" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_volume0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_volume_delta_new0" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_volume_delta_old0";
        INSERT INTO "dbrdf_volume_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_volume_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_volume_delta_new0";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Celebrity_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Celebrity_delta_old"(s) SELECT t0.s FROM "dbrdf_Celebrity" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Celebrity_delta_old" ON "dbrdf_Celebrity_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Celebrity_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Celebrity$delta_new>(?Y) :- <http://dbpedia.org/ontology/Celebrity$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Celebrity_delta_new"(s) SELECT t1.o FROM "dbrdf_Celebrity_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Celebrity" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Celebrity"(s) SELECT DISTINCT t0.s FROM "dbrdf_Celebrity_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Celebrity_delta_old";
        INSERT INTO "dbrdf_Celebrity_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Celebrity_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Celebrity_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectParticipant_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_projectParticipant_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_projectParticipant" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_projectParticipant" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_projectParticipant" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_FieldHockeyLeague_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_FieldHockeyLeague_delta_old"(s) SELECT t0.s FROM "dbrdf_FieldHockeyLeague" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_FieldHockeyLeague_delta_old" ON "dbrdf_FieldHockeyLeague_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_FieldHockeyLeague_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/FieldHockeyLeague$delta_new>(?Y) :- <http://dbpedia.org/ontology/FieldHockeyLeague$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_FieldHockeyLeague_delta_new"(s) SELECT t1.o FROM "dbrdf_FieldHockeyLeague_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_FieldHockeyLeague" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_FieldHockeyLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_FieldHockeyLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_FieldHockeyLeague_delta_old";
        INSERT INTO "dbrdf_FieldHockeyLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_FieldHockeyLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_FieldHockeyLeague_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 375
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 376
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_port1DockedTime_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_port1DockedTime_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_port1DockedTime" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_port1DockedTime_delta_old" ON "dbrdf_port1DockedTime_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_port1DockedTime_delta_old" ON "dbrdf_port1DockedTime_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_port1DockedTime_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Governor_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Governor_delta_old"(s) SELECT t0.s FROM "dbrdf_Governor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Governor_delta_old" ON "dbrdf_Governor_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Governor_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Governor$delta_new>(?Y) :- <http://dbpedia.org/ontology/Governor$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Governor_delta_new"(s) SELECT t1.o FROM "dbrdf_Governor_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Governor" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Governor"(s) SELECT DISTINCT t0.s FROM "dbrdf_Governor_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Governor_delta_old";
        INSERT INTO "dbrdf_Governor_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Governor_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Governor_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_SoccerManager_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SoccerManager_delta_old"(s) SELECT t0.s FROM "dbrdf_SoccerManager" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SoccerManager_delta_old" ON "dbrdf_SoccerManager_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SoccerManager_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/SoccerManager$delta_new>(?Y) :- <http://dbpedia.org/ontology/SoccerManager$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_SoccerManager_delta_new"(s) SELECT t1.o FROM "dbrdf_SoccerManager_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_SoccerManager" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_SoccerManager"(s) SELECT DISTINCT t0.s FROM "dbrdf_SoccerManager_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SoccerManager_delta_old";
        INSERT INTO "dbrdf_SoccerManager_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SoccerManager_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SoccerManager_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_largestMetro_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_largestMetro_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_largestMetro" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_largestMetro" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_largestMetro" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 384
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 385
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_recommissioningDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_recommissioningDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_recommissioningDate" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_recommissioningDate" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_recommissioningDate" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_weddingParentsDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_weddingParentsDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_weddingParentsDate" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_weddingParentsDate" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_weddingParentsDate" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_BowlingLeague_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_BowlingLeague_delta_old"(s) SELECT t0.s FROM "dbrdf_BowlingLeague" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_BowlingLeague_delta_old" ON "dbrdf_BowlingLeague_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_BowlingLeague_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/BowlingLeague$delta_new>(?Y) :- <http://dbpedia.org/ontology/BowlingLeague$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_BowlingLeague_delta_new"(s) SELECT t1.o FROM "dbrdf_BowlingLeague_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_BowlingLeague" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_BowlingLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_BowlingLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_BowlingLeague_delta_old";
        INSERT INTO "dbrdf_BowlingLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_BowlingLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_BowlingLeague_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lowerEarthOrbitPayload_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lowerEarthOrbitPayload_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lowerEarthOrbitPayload" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lowerEarthOrbitPayload_delta_old" ON "dbrdf_lowerEarthOrbitPayload_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lowerEarthOrbitPayload_delta_old" ON "dbrdf_lowerEarthOrbitPayload_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lowerEarthOrbitPayload_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 402
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 403
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_chorusCharacterInPlay_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_chorusCharacterInPlay_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_chorusCharacterInPlay" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_chorusCharacterInPlay" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_chorusCharacterInPlay" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_equity_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_equity_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_equity" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_equity" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_equity" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstRace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstRace_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_firstRace" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_firstRace" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_firstRace" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_volume_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_volume_delta_old1"(s, o) SELECT t0.s, t0.o FROM "dbrdf_volume1" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_volume_delta_old1" ON "dbrdf_volume_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_volume_delta_old1" ON "dbrdf_volume_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_volume_delta_new1"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Planet/volume$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Planet/volume$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_volume_delta_new1"(s, o) SELECT t1.o, t0.o FROM "dbrdf_volume_delta_old1" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_volume1" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/Planet/volume$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/Planet/volume$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_volume_delta_new1"(s, o) SELECT t0.s, t1.o FROM "dbrdf_volume_delta_old1" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_volume1" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_volume1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_volume_delta_new1" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_volume_delta_old1";
        INSERT INTO "dbrdf_volume_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_volume_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_volume_delta_new1";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_TelevisionSeason_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_TelevisionSeason_delta_old"(s) SELECT t0.s FROM "dbrdf_TelevisionSeason" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_TelevisionSeason_delta_old" ON "dbrdf_TelevisionSeason_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_TelevisionSeason_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/TelevisionSeason$delta_new>(?Y) :- <http://dbpedia.org/ontology/TelevisionSeason$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_TelevisionSeason_delta_new"(s) SELECT t1.o FROM "dbrdf_TelevisionSeason_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_TelevisionSeason" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_TelevisionSeason"(s) SELECT DISTINCT t0.s FROM "dbrdf_TelevisionSeason_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_TelevisionSeason_delta_old";
        INSERT INTO "dbrdf_TelevisionSeason_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_TelevisionSeason_delta_new" t0;
        TRUNCATE TABLE "dbrdf_TelevisionSeason_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_meltingPoint_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_meltingPoint_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_meltingPoint0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_meltingPoint_delta_old0" ON "dbrdf_meltingPoint_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_meltingPoint_delta_old0" ON "dbrdf_meltingPoint_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_meltingPoint_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/ChemicalSubstance/meltingPoint$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/ChemicalSubstance/meltingPoint$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_meltingPoint_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_meltingPoint_delta_old0" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_meltingPoint0" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/ChemicalSubstance/meltingPoint$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/ChemicalSubstance/meltingPoint$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_meltingPoint_delta_new0"(s, o) SELECT t0.s, t1.o FROM "dbrdf_meltingPoint_delta_old0" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_meltingPoint0" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_meltingPoint0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_meltingPoint_delta_new0" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_meltingPoint_delta_old0";
        INSERT INTO "dbrdf_meltingPoint_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_meltingPoint_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_meltingPoint_delta_new0";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 428
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 429
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_RoadTunnel_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_RoadTunnel_delta_old"(s) SELECT t0.s FROM "dbrdf_RoadTunnel" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_RoadTunnel_delta_old" ON "dbrdf_RoadTunnel_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_RoadTunnel_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/RoadTunnel$delta_new>(?Y) :- <http://dbpedia.org/ontology/RoadTunnel$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_RoadTunnel_delta_new"(s) SELECT t1.o FROM "dbrdf_RoadTunnel_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_RoadTunnel" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_RoadTunnel"(s) SELECT DISTINCT t0.s FROM "dbrdf_RoadTunnel_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_RoadTunnel_delta_old";
        INSERT INTO "dbrdf_RoadTunnel_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_RoadTunnel_delta_new" t0;
        TRUNCATE TABLE "dbrdf_RoadTunnel_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Lighthouse_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Lighthouse_delta_old"(s) SELECT t0.s FROM "dbrdf_Lighthouse" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Lighthouse_delta_old" ON "dbrdf_Lighthouse_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Lighthouse_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Lighthouse$delta_new>(?Y) :- <http://dbpedia.org/ontology/Lighthouse$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Lighthouse_delta_new"(s) SELECT t1.o FROM "dbrdf_Lighthouse_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Lighthouse" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Lighthouse"(s) SELECT DISTINCT t0.s FROM "dbrdf_Lighthouse_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Lighthouse_delta_old";
        INSERT INTO "dbrdf_Lighthouse_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Lighthouse_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Lighthouse_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_HumanGeneLocation_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_HumanGeneLocation_delta_old"(s) SELECT t0.s FROM "dbrdf_HumanGeneLocation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_HumanGeneLocation_delta_old" ON "dbrdf_HumanGeneLocation_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_HumanGeneLocation_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/HumanGeneLocation$delta_new>(?Y) :- <http://dbpedia.org/ontology/HumanGeneLocation$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_HumanGeneLocation_delta_new"(s) SELECT t1.o FROM "dbrdf_HumanGeneLocation_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_HumanGeneLocation" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_HumanGeneLocation"(s) SELECT DISTINCT t0.s FROM "dbrdf_HumanGeneLocation_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_HumanGeneLocation_delta_old";
        INSERT INTO "dbrdf_HumanGeneLocation_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_HumanGeneLocation_delta_new" t0;
        TRUNCATE TABLE "dbrdf_HumanGeneLocation_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 439
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 440
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_InlineHockeyLeague_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_InlineHockeyLeague_delta_old"(s) SELECT t0.s FROM "dbrdf_InlineHockeyLeague" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_InlineHockeyLeague_delta_old" ON "dbrdf_InlineHockeyLeague_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_InlineHockeyLeague_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/InlineHockeyLeague$delta_new>(?Y) :- <http://dbpedia.org/ontology/InlineHockeyLeague$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_InlineHockeyLeague_delta_new"(s) SELECT t1.o FROM "dbrdf_InlineHockeyLeague_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_InlineHockeyLeague" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_InlineHockeyLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_InlineHockeyLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_InlineHockeyLeague_delta_old";
        INSERT INTO "dbrdf_InlineHockeyLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_InlineHockeyLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_InlineHockeyLeague_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Nonrecursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_starring_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_starring_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_starring0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_starring_delta_old0" ON "dbrdf_starring_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_starring_delta_old0" ON "dbrdf_starring_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_starring_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/starring$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/starring$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_starring_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_starring_delta_old0" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_starring0" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/starring$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/starring$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_starring_delta_new0"(s, o) SELECT t0.s, t1.o FROM "dbrdf_starring_delta_old0" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_starring0" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_starring0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_starring_delta_new0" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_starring_delta_old0";
        INSERT INTO "dbrdf_starring_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_starring_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_starring_delta_new0";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lunarEvaTime_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lunarEvaTime_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lunarEvaTime0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lunarEvaTime_delta_old0" ON "dbrdf_lunarEvaTime_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_lunarEvaTime_delta_old0" ON "dbrdf_lunarEvaTime_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lunarEvaTime_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/lunarEvaTime$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/lunarEvaTime$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_lunarEvaTime_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_lunarEvaTime_delta_old0" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_lunarEvaTime0" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/lunarEvaTime$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/lunarEvaTime$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_lunarEvaTime_delta_new0"(s, o) SELECT t0.s, t1.o FROM "dbrdf_lunarEvaTime_delta_old0" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_lunarEvaTime0" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_lunarEvaTime0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lunarEvaTime_delta_new0" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_lunarEvaTime_delta_old0";
        INSERT INTO "dbrdf_lunarEvaTime_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lunarEvaTime_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_lunarEvaTime_delta_new0";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Judge_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Judge_delta_old"(s) SELECT t0.s FROM "dbrdf_Judge" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Judge_delta_old" ON "dbrdf_Judge_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Judge_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Judge$delta_new>(?Y) :- <http://dbpedia.org/ontology/Judge$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Judge_delta_new"(s) SELECT t1.o FROM "dbrdf_Judge_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Judge" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Judge"(s) SELECT DISTINCT t0.s FROM "dbrdf_Judge_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Judge_delta_old";
        INSERT INTO "dbrdf_Judge_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Judge_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Judge_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 450
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 451
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_periapsis_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_periapsis_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_periapsis0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_periapsis_delta_old0" ON "dbrdf_periapsis_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_periapsis_delta_old0" ON "dbrdf_periapsis_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_periapsis_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/periapsis$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/periapsis$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_periapsis_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_periapsis_delta_old0" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_periapsis0" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/periapsis$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/periapsis$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_periapsis_delta_new0"(s, o) SELECT t0.s, t1.o FROM "dbrdf_periapsis_delta_old0" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_periapsis0" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_periapsis0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_periapsis_delta_new0" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_periapsis_delta_old0";
        INSERT INTO "dbrdf_periapsis_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_periapsis_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_periapsis_delta_new0";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_discharge_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_discharge_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_discharge0" t0;
    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/Stream/discharge$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Stream/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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_discharge0" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/Stream/discharge$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/Stream/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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_discharge0" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 474
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_WomensTennisAssociationTournament_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_WomensTennisAssociationTournament_delta_old"(s) SELECT t0.s FROM "dbrdf_WomensTennisAssociationTournament" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_WomensTennisAssociationTournament_delta_old" ON "dbrdf_WomensTennisAssociationTournament_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_WomensTennisAssociationTournament_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/WomensTennisAssociationTournament$delta_new>(?Y) :- <http://dbpedia.org/ontology/WomensTennisAssociationTournament$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_WomensTennisAssociationTournament_delta_new"(s) SELECT t1.o FROM "dbrdf_WomensTennisAssociationTournament_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_WomensTennisAssociationTournament" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_WomensTennisAssociationTournament"(s) SELECT DISTINCT t0.s FROM "dbrdf_WomensTennisAssociationTournament_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_WomensTennisAssociationTournament_delta_old";
        INSERT INTO "dbrdf_WomensTennisAssociationTournament_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_WomensTennisAssociationTournament_delta_new" t0;
        TRUNCATE TABLE "dbrdf_WomensTennisAssociationTournament_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 475
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 476
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 477
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstLaunchDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstLaunchDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_firstLaunchDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstLaunchDate_delta_old" ON "dbrdf_firstLaunchDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstLaunchDate_delta_old" ON "dbrdf_firstLaunchDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstLaunchDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/firstLaunchDate$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/firstLaunchDate$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_firstLaunchDate_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_firstLaunchDate_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_firstLaunchDate" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/firstLaunchDate$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/firstLaunchDate$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_firstLaunchDate_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_firstLaunchDate_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_firstLaunchDate" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_firstLaunchDate"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_firstLaunchDate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_firstLaunchDate_delta_old";
        INSERT INTO "dbrdf_firstLaunchDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_firstLaunchDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_firstLaunchDate_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 478
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 479
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 480
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 481
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_surfaceFormOccurrenceOffset_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_surfaceFormOccurrenceOffset_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_surfaceFormOccurrenceOffset" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_surfaceFormOccurrenceOffset_delta_old" ON "dbrdf_surfaceFormOccurrenceOffset_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_surfaceFormOccurrenceOffset_delta_old" ON "dbrdf_surfaceFormOccurrenceOffset_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_surfaceFormOccurrenceOffset_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/surfaceFormOccurrenceOffset$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/surfaceFormOccurrenceOffset$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_surfaceFormOccurrenceOffset_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_surfaceFormOccurrenceOffset_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_surfaceFormOccurrenceOffset" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/surfaceFormOccurrenceOffset$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/surfaceFormOccurrenceOffset$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_surfaceFormOccurrenceOffset_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_surfaceFormOccurrenceOffset_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_surfaceFormOccurrenceOffset" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_surfaceFormOccurrenceOffset"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_surfaceFormOccurrenceOffset_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_surfaceFormOccurrenceOffset_delta_old";
        INSERT INTO "dbrdf_surfaceFormOccurrenceOffset_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_surfaceFormOccurrenceOffset_delta_new" t0;
        TRUNCATE TABLE "dbrdf_surfaceFormOccurrenceOffset_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 482
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 483
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 484
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationRural_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_populationRural_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_populationRural" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_populationRural_delta_old" ON "dbrdf_populationRural_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_populationRural_delta_old" ON "dbrdf_populationRural_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationRural_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/populationRural$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/populationRural$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_populationRural_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_populationRural_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_populationRural" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_populationRural" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_musicalArtist_delta_old"(s integer, o integer) ON COMMIT DROP;
