        INSERT INTO "dbrdf_areaOfCatchment_delta_new0"(s, o) SELECT t0.s, t1.o FROM "dbrdf_areaOfCatchment_delta_old0" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_areaOfCatchment0" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_areaOfCatchment0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_areaOfCatchment_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_areaOfCatchment_delta_old0";
        INSERT INTO "dbrdf_areaOfCatchment_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_areaOfCatchment_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_areaOfCatchment_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1509
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_productionYears_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_productionYears_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_productionYears" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_productionYears_delta_old" ON "dbrdf_productionYears_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_productionYears_delta_old" ON "dbrdf_productionYears_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_productionYears_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1510
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_PoloLeague_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_PoloLeague_delta_old"(s) SELECT t0.s FROM "dbrdf_PoloLeague" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_PoloLeague_delta_old" ON "dbrdf_PoloLeague_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_PoloLeague_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/PoloLeague$delta_new>(?Y) :- <http://dbpedia.org/ontology/PoloLeague$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_PoloLeague_delta_new"(s) SELECT t1.o FROM "dbrdf_PoloLeague_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_PoloLeague" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_PoloLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_PoloLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_PoloLeague_delta_old";
        INSERT INTO "dbrdf_PoloLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_PoloLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_PoloLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1511
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_usedInWar_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_usedInWar_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_usedInWar" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_usedInWar_delta_old" ON "dbrdf_usedInWar_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_usedInWar_delta_old" ON "dbrdf_usedInWar_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_usedInWar_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1512
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfAcademicStaff_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfAcademicStaff_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfAcademicStaff" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfAcademicStaff_delta_old" ON "dbrdf_numberOfAcademicStaff_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfAcademicStaff_delta_old" ON "dbrdf_numberOfAcademicStaff_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfAcademicStaff_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1513
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_virtualChannel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_virtualChannel_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_virtualChannel" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_virtualChannel_delta_old" ON "dbrdf_virtualChannel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_virtualChannel_delta_old" ON "dbrdf_virtualChannel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_virtualChannel_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1514
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_wineYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_wineYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_wineYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_wineYear_delta_old" ON "dbrdf_wineYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_wineYear_delta_old" ON "dbrdf_wineYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_wineYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1515
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_deliveryDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_deliveryDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_deliveryDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_deliveryDate_delta_old" ON "dbrdf_deliveryDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_deliveryDate_delta_old" ON "dbrdf_deliveryDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_deliveryDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1516
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_arm_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_arm_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_arm" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_arm_delta_old" ON "dbrdf_arm_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_arm_delta_old" ON "dbrdf_arm_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_arm_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1517
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerCoach_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_formerCoach_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_formerCoach" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_formerCoach_delta_old" ON "dbrdf_formerCoach_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_formerCoach_delta_old" ON "dbrdf_formerCoach_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerCoach_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1518
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lowerEarthOrbitPayload_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lowerEarthOrbitPayload_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lowerEarthOrbitPayload0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lowerEarthOrbitPayload_delta_old0" ON "dbrdf_lowerEarthOrbitPayload_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_lowerEarthOrbitPayload_delta_old0" ON "dbrdf_lowerEarthOrbitPayload_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lowerEarthOrbitPayload_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/lowerEarthOrbitPayload$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/lowerEarthOrbitPayload$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_lowerEarthOrbitPayload_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_lowerEarthOrbitPayload_delta_old0" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_lowerEarthOrbitPayload0" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_lowerEarthOrbitPayload0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lowerEarthOrbitPayload_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_lowerEarthOrbitPayload_delta_old0";
        INSERT INTO "dbrdf_lowerEarthOrbitPayload_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lowerEarthOrbitPayload_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_lowerEarthOrbitPayload_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1519
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ratio_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ratio_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_ratio" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ratio_delta_old" ON "dbrdf_ratio_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ratio_delta_old" ON "dbrdf_ratio_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ratio_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1520
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_toll_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_toll_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_toll" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_toll_delta_old" ON "dbrdf_toll_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_toll_delta_old" ON "dbrdf_toll_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_toll_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1521
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_minimumInclination_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_minimumInclination_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_minimumInclination" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_minimumInclination_delta_old" ON "dbrdf_minimumInclination_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_minimumInclination_delta_old" ON "dbrdf_minimumInclination_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_minimumInclination_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1522
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_routeEndDirection_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_routeEndDirection_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_routeEndDirection" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_routeEndDirection_delta_old" ON "dbrdf_routeEndDirection_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_routeEndDirection_delta_old" ON "dbrdf_routeEndDirection_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_routeEndDirection_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1523
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_seatingCapacity_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_seatingCapacity_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_seatingCapacity" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_seatingCapacity_delta_old" ON "dbrdf_seatingCapacity_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_seatingCapacity_delta_old" ON "dbrdf_seatingCapacity_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_seatingCapacity_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1524
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_distanceToCardiff_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_distanceToCardiff_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_distanceToCardiff" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_distanceToCardiff_delta_old" ON "dbrdf_distanceToCardiff_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_distanceToCardiff_delta_old" ON "dbrdf_distanceToCardiff_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_distanceToCardiff_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1525
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nutsCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nutsCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_nutsCode" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nutsCode_delta_old" ON "dbrdf_nutsCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nutsCode_delta_old" ON "dbrdf_nutsCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nutsCode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1526
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_year_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_year_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_year" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_year_delta_old" ON "dbrdf_year_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_year_delta_old" ON "dbrdf_year_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_year_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1527
    ---- DEPENDS ON: 1526, 1451, 1310, 631, 435, 137, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Sales>(?X) :- <http://dbpedia.org/ontology/endYearOfSales>(?X,?X1) .
    INSERT INTO "dbrdf_Sales"(s) SELECT DISTINCT t0.s FROM "dbrdf_endYearOfSales" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Sales" 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_Sales_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Sales_delta_old"(s) SELECT t0.s FROM "dbrdf_Sales" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Sales_delta_old" ON "dbrdf_Sales_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Sales_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/Sales$delta_new>(?Y) :- <http://dbpedia.org/ontology/Sales$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Sales_delta_new"(s) SELECT t1.o FROM "dbrdf_Sales_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Sales" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Sales"(s) SELECT DISTINCT t0.s FROM "dbrdf_Sales_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Sales_delta_old";
        INSERT INTO "dbrdf_Sales_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Sales_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Sales_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1528
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_landingVehicle_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_landingVehicle_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_landingVehicle" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_landingVehicle_delta_old" ON "dbrdf_landingVehicle_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_landingVehicle_delta_old" ON "dbrdf_landingVehicle_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_landingVehicle_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1529
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_supplementalDraftYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_supplementalDraftYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_supplementalDraftYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_supplementalDraftYear_delta_old" ON "dbrdf_supplementalDraftYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_supplementalDraftYear_delta_old" ON "dbrdf_supplementalDraftYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_supplementalDraftYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1530
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_suppreddedDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_suppreddedDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_suppreddedDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_suppreddedDate_delta_old" ON "dbrdf_suppreddedDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_suppreddedDate_delta_old" ON "dbrdf_suppreddedDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_suppreddedDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1531
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mapDescription_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mapDescription_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_mapDescription" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mapDescription_delta_old" ON "dbrdf_mapDescription_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mapDescription_delta_old" ON "dbrdf_mapDescription_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mapDescription_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1532
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_typeOfElectrification_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_typeOfElectrification_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_typeOfElectrification" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_typeOfElectrification_delta_old" ON "dbrdf_typeOfElectrification_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_typeOfElectrification_delta_old" ON "dbrdf_typeOfElectrification_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_typeOfElectrification_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1533
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectBudgetTotal_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_projectBudgetTotal_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_projectBudgetTotal" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_projectBudgetTotal_delta_old" ON "dbrdf_projectBudgetTotal_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_projectBudgetTotal_delta_old" ON "dbrdf_projectBudgetTotal_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectBudgetTotal_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1534
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerBandMember_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_formerBandMember_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_formerBandMember" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_formerBandMember_delta_old" ON "dbrdf_formerBandMember_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_formerBandMember_delta_old" ON "dbrdf_formerBandMember_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerBandMember_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1535
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfStars_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfStars_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfStars" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfStars_delta_old" ON "dbrdf_numberOfStars_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfStars_delta_old" ON "dbrdf_numberOfStars_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfStars_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1536
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_amgid_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_amgid_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_amgid" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_amgid_delta_old" ON "dbrdf_amgid_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_amgid_delta_old" ON "dbrdf_amgid_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_amgid_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1537
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_recordDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_recordDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_recordDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_recordDate_delta_old" ON "dbrdf_recordDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_recordDate_delta_old" ON "dbrdf_recordDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_recordDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1538
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_iataLocationIdentifier_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_iataLocationIdentifier_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_iataLocationIdentifier" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_iataLocationIdentifier_delta_old" ON "dbrdf_iataLocationIdentifier_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_iataLocationIdentifier_delta_old" ON "dbrdf_iataLocationIdentifier_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_iataLocationIdentifier_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1539
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_buildingEndYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_buildingEndYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_buildingEndYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_buildingEndYear_delta_old" ON "dbrdf_buildingEndYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_buildingEndYear_delta_old" ON "dbrdf_buildingEndYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_buildingEndYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1540
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_parentOrganisation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_parentOrganisation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_parentOrganisation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_parentOrganisation_delta_old" ON "dbrdf_parentOrganisation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_parentOrganisation_delta_old" ON "dbrdf_parentOrganisation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_parentOrganisation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1541
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_managerYears_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_managerYears_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_managerYears" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_managerYears_delta_old" ON "dbrdf_managerYears_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_managerYears_delta_old" ON "dbrdf_managerYears_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_managerYears_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1542
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_openingDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_openingDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_openingDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_openingDate_delta_old" ON "dbrdf_openingDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_openingDate_delta_old" ON "dbrdf_openingDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_openingDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1543
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_modelStartYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_modelStartYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_modelStartYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_modelStartYear_delta_old" ON "dbrdf_modelStartYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_modelStartYear_delta_old" ON "dbrdf_modelStartYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_modelStartYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1544
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_MixedMartialArtsLeague_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_MixedMartialArtsLeague_delta_old"(s) SELECT t0.s FROM "dbrdf_MixedMartialArtsLeague" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_MixedMartialArtsLeague_delta_old" ON "dbrdf_MixedMartialArtsLeague_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_MixedMartialArtsLeague_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/MixedMartialArtsLeague$delta_new>(?Y) :- <http://dbpedia.org/ontology/MixedMartialArtsLeague$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_MixedMartialArtsLeague_delta_new"(s) SELECT t1.o FROM "dbrdf_MixedMartialArtsLeague_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_MixedMartialArtsLeague" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_MixedMartialArtsLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_MixedMartialArtsLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_MixedMartialArtsLeague_delta_old";
        INSERT INTO "dbrdf_MixedMartialArtsLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_MixedMartialArtsLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_MixedMartialArtsLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1545
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cmpEvaDuration_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cmpEvaDuration_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_cmpEvaDuration0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cmpEvaDuration_delta_old0" ON "dbrdf_cmpEvaDuration_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_cmpEvaDuration_delta_old0" ON "dbrdf_cmpEvaDuration_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cmpEvaDuration_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/cmpEvaDuration$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/cmpEvaDuration$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_cmpEvaDuration_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_cmpEvaDuration_delta_old0" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_cmpEvaDuration0" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_cmpEvaDuration0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cmpEvaDuration_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_cmpEvaDuration_delta_old0";
        INSERT INTO "dbrdf_cmpEvaDuration_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cmpEvaDuration_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_cmpEvaDuration_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1546
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfWineries_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfWineries_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfWineries" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfWineries_delta_old" ON "dbrdf_numberOfWineries_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfWineries_delta_old" ON "dbrdf_numberOfWineries_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfWineries_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1547
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_canonizedBy_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_canonizedBy_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_canonizedBy" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_canonizedBy_delta_old" ON "dbrdf_canonizedBy_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_canonizedBy_delta_old" ON "dbrdf_canonizedBy_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_canonizedBy_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1548
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfMembersAsOf_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfMembersAsOf_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfMembersAsOf" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfMembersAsOf_delta_old" ON "dbrdf_numberOfMembersAsOf_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfMembersAsOf_delta_old" ON "dbrdf_numberOfMembersAsOf_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfMembersAsOf_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1549
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_trainer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_trainer_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_trainer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_trainer_delta_old" ON "dbrdf_trainer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_trainer_delta_old" ON "dbrdf_trainer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_trainer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1550
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftRecon_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftRecon_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_aircraftRecon" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftRecon_delta_old" ON "dbrdf_aircraftRecon_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftRecon_delta_old" ON "dbrdf_aircraftRecon_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftRecon_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1551
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_coastLine_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_coastLine_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_coastLine" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_coastLine_delta_old" ON "dbrdf_coastLine_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_coastLine_delta_old" ON "dbrdf_coastLine_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_coastLine_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1552
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_europeanParliamentGroup_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_europeanParliamentGroup_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_europeanParliamentGroup" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_europeanParliamentGroup_delta_old" ON "dbrdf_europeanParliamentGroup_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_europeanParliamentGroup_delta_old" ON "dbrdf_europeanParliamentGroup_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_europeanParliamentGroup_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1553
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_militaryRank_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_militaryRank_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_militaryRank" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_militaryRank_delta_old" ON "dbrdf_militaryRank_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_militaryRank_delta_old" ON "dbrdf_militaryRank_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_militaryRank_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1554
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_demolitionYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_demolitionYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_demolitionYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_demolitionYear_delta_old" ON "dbrdf_demolitionYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_demolitionYear_delta_old" ON "dbrdf_demolitionYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_demolitionYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1555
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_layout_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_layout_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_layout" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_layout_delta_old" ON "dbrdf_layout_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_layout_delta_old" ON "dbrdf_layout_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_layout_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1556
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_staff_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_staff_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_staff" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_staff_delta_old" ON "dbrdf_staff_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_staff_delta_old" ON "dbrdf_staff_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_staff_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1557
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumTemperature_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_maximumTemperature_delta_old1"(s, o) SELECT t0.s, t0.o FROM "dbrdf_maximumTemperature1" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_maximumTemperature_delta_old1" ON "dbrdf_maximumTemperature_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_maximumTemperature_delta_old1" ON "dbrdf_maximumTemperature_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumTemperature_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/maximumTemperature$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/maximumTemperature$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_maximumTemperature_delta_new1"(s, o) SELECT t1.o, t0.o FROM "dbrdf_maximumTemperature_delta_old1" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_maximumTemperature1" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_maximumTemperature1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_maximumTemperature_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_maximumTemperature_delta_old1";
        INSERT INTO "dbrdf_maximumTemperature_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_maximumTemperature_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_maximumTemperature_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1558
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_modelEndYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_modelEndYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_modelEndYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_modelEndYear_delta_old" ON "dbrdf_modelEndYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_modelEndYear_delta_old" ON "dbrdf_modelEndYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_modelEndYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1559
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_eloRecord_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_eloRecord_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_eloRecord" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_eloRecord_delta_old" ON "dbrdf_eloRecord_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_eloRecord_delta_old" ON "dbrdf_eloRecord_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_eloRecord_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1560
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_previousEditor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_previousEditor_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_previousEditor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_previousEditor_delta_old" ON "dbrdf_previousEditor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_previousEditor_delta_old" ON "dbrdf_previousEditor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_previousEditor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1561
    ---- DEPENDS ON: 1560, 1056, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- [Rule] <http://dbpedia.org/ontology/Magazine>(?X) :- <http://dbpedia.org/ontology/editorTitle>(?X,?X1) .
    INSERT INTO "dbrdf_Magazine"(s) SELECT DISTINCT t0.s FROM "dbrdf_editorTitle" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Magazine" 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_Magazine_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Magazine_delta_old"(s) SELECT t0.s FROM "dbrdf_Magazine" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Magazine_delta_old" ON "dbrdf_Magazine_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Magazine_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/Magazine$delta_new>(?Y) :- <http://dbpedia.org/ontology/Magazine$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Magazine_delta_new"(s) SELECT t1.o FROM "dbrdf_Magazine_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Magazine" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Magazine"(s) SELECT DISTINCT t0.s FROM "dbrdf_Magazine_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Magazine_delta_old";
        INSERT INTO "dbrdf_Magazine_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Magazine_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Magazine_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1562
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_crewMember_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_crewMember_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_crewMember" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_crewMember_delta_old" ON "dbrdf_crewMember_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_crewMember_delta_old" ON "dbrdf_crewMember_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_crewMember_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1563
    ---- DEPENDS ON: 1562, 1351, 802, 318, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Astronaut>(?X1) :- <http://dbpedia.org/ontology/crewMember>(?X,?X1) .
    INSERT INTO "dbrdf_Astronaut"(s) SELECT DISTINCT t0.o FROM "dbrdf_crewMember" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Astronaut" ex WHERE ex.s = 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_Astronaut_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Astronaut_delta_old"(s) SELECT t0.s FROM "dbrdf_Astronaut" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Astronaut_delta_old" ON "dbrdf_Astronaut_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Astronaut_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/Astronaut$delta_new>(?Y) :- <http://dbpedia.org/ontology/Astronaut$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Astronaut_delta_new"(s) SELECT t1.o FROM "dbrdf_Astronaut_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Astronaut" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Astronaut"(s) SELECT DISTINCT t0.s FROM "dbrdf_Astronaut_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Astronaut_delta_old";
        INSERT INTO "dbrdf_Astronaut_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Astronaut_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Astronaut_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1564
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_elo_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_elo_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_elo" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_elo_delta_old" ON "dbrdf_elo_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_elo_delta_old" ON "dbrdf_elo_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_elo_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1565
    ---- DEPENDS ON: 1564, 1559, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- [Rule] <http://dbpedia.org/ontology/ChessPlayer>(?X) :- <http://dbpedia.org/ontology/eloRecord>(?X,?X1) .
    INSERT INTO "dbrdf_ChessPlayer"(s) SELECT DISTINCT t0.s FROM "dbrdf_eloRecord" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_ChessPlayer" 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_ChessPlayer_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ChessPlayer_delta_old"(s) SELECT t0.s FROM "dbrdf_ChessPlayer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ChessPlayer_delta_old" ON "dbrdf_ChessPlayer_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ChessPlayer_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/ChessPlayer$delta_new>(?Y) :- <http://dbpedia.org/ontology/ChessPlayer$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_ChessPlayer_delta_new"(s) SELECT t1.o FROM "dbrdf_ChessPlayer_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_ChessPlayer" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_ChessPlayer"(s) SELECT DISTINCT t0.s FROM "dbrdf_ChessPlayer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_ChessPlayer_delta_old";
        INSERT INTO "dbrdf_ChessPlayer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_ChessPlayer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ChessPlayer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1566
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_soccerTournamentTopScorer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_soccerTournamentTopScorer_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_soccerTournamentTopScorer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_soccerTournamentTopScorer_delta_old" ON "dbrdf_soccerTournamentTopScorer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_soccerTournamentTopScorer_delta_old" ON "dbrdf_soccerTournamentTopScorer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_soccerTournamentTopScorer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1567
    ---- DEPENDS ON: 1566, 1406, 1384, 1309, 1005, 197, 162, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/SoccerTournament>(?X1) :- <http://dbpedia.org/ontology/soccerTournamentThisSeason>(?X,?X1) .
    INSERT INTO "dbrdf_SoccerTournament"(s) SELECT DISTINCT t0.o FROM "dbrdf_soccerTournamentThisSeason" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_SoccerTournament" ex WHERE ex.s = 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_SoccerTournament_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SoccerTournament_delta_old"(s) SELECT t0.s FROM "dbrdf_SoccerTournament" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SoccerTournament_delta_old" ON "dbrdf_SoccerTournament_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SoccerTournament_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/SoccerTournament$delta_new>(?Y) :- <http://dbpedia.org/ontology/SoccerTournament$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_SoccerTournament_delta_new"(s) SELECT t1.o FROM "dbrdf_SoccerTournament_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_SoccerTournament" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_SoccerTournament"(s) SELECT DISTINCT t0.s FROM "dbrdf_SoccerTournament_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SoccerTournament_delta_old";
        INSERT INTO "dbrdf_SoccerTournament_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SoccerTournament_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SoccerTournament_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1568
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_barPassRate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_barPassRate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_barPassRate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_barPassRate_delta_old" ON "dbrdf_barPassRate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_barPassRate_delta_old" ON "dbrdf_barPassRate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_barPassRate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1569
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_operator_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_operator_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_operator" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_operator_delta_old" ON "dbrdf_operator_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_operator_delta_old" ON "dbrdf_operator_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_operator_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1570
    ---- DEPENDS ON: 108, 100, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Song>(?X) :- <http://dbpedia.org/ontology/EurovisionSongContestEntry>(?X) .
    INSERT INTO "dbrdf_Song"(s) SELECT t0.s FROM "dbrdf_EurovisionSongContestEntry" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Song" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/Song>(?X) :- <http://dbpedia.org/ontology/trackNumber>(?X,?X1) .
    INSERT INTO "dbrdf_Song"(s) SELECT DISTINCT t0.s FROM "dbrdf_trackNumber" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Song" 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_Song_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Song_delta_old"(s) SELECT t0.s FROM "dbrdf_Song" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Song_delta_old" ON "dbrdf_Song_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Song_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_MusicRecording_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_MusicRecording_delta_old"(s) SELECT t0.s FROM "dbrdf_MusicRecording" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_MusicRecording_delta_old" ON "dbrdf_MusicRecording_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_MusicRecording_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/Song$delta_new>(?X) :- <http://schema.org/MusicRecording$delta_old>(?X) .
        INSERT INTO "dbrdf_Song_delta_new"(s) SELECT t0.s FROM "dbrdf_MusicRecording_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Song" ex WHERE ex.s = t0.s);


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


        -- <http://schema.org/MusicRecording$delta_new>(?X) :- <http://dbpedia.org/ontology/Song$delta_old>(?X) .
        INSERT INTO "dbrdf_MusicRecording_delta_new"(s) SELECT t0.s FROM "dbrdf_Song_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_MusicRecording" ex WHERE ex.s = t0.s);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Song"(s) SELECT DISTINCT t0.s FROM "dbrdf_Song_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Song_delta_old";
        INSERT INTO "dbrdf_Song_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Song_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Song_delta_new";

        INSERT INTO "dbrdf_MusicRecording"(s) SELECT DISTINCT t0.s FROM "dbrdf_MusicRecording_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_MusicRecording_delta_old";
        INSERT INTO "dbrdf_MusicRecording_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_MusicRecording_delta_new" t0;
        TRUNCATE TABLE "dbrdf_MusicRecording_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1571
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nationalTeam_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nationalTeam_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_nationalTeam" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nationalTeam_delta_old" ON "dbrdf_nationalTeam_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nationalTeam_delta_old" ON "dbrdf_nationalTeam_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nationalTeam_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1572
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_fansgroup_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_fansgroup_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_fansgroup" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_fansgroup_delta_old" ON "dbrdf_fansgroup_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_fansgroup_delta_old" ON "dbrdf_fansgroup_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_fansgroup_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1573
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_wins_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_wins_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_wins" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_wins_delta_old" ON "dbrdf_wins_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_wins_delta_old" ON "dbrdf_wins_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_wins_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1574
    ---- DEPENDS ON: 1573, 1489, 1434, 1114, 1000, 926, 909, 733, 567, 436, 396, 319, 312, 301, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/FormulaOneRacer>(?X) :- <http://dbpedia.org/ontology/careerPoints>(?X,?X1) .
    INSERT INTO "dbrdf_FormulaOneRacer"(s) SELECT DISTINCT t0.s FROM "dbrdf_careerPoints" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_FormulaOneRacer" 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_FormulaOneRacer_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_FormulaOneRacer_delta_old"(s) SELECT t0.s FROM "dbrdf_FormulaOneRacer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_FormulaOneRacer_delta_old" ON "dbrdf_FormulaOneRacer_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_FormulaOneRacer_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/FormulaOneRacer$delta_new>(?Y) :- <http://dbpedia.org/ontology/FormulaOneRacer$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_FormulaOneRacer_delta_new"(s) SELECT t1.o FROM "dbrdf_FormulaOneRacer_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_FormulaOneRacer" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_FormulaOneRacer"(s) SELECT DISTINCT t0.s FROM "dbrdf_FormulaOneRacer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_FormulaOneRacer_delta_old";
        INSERT INTO "dbrdf_FormulaOneRacer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_FormulaOneRacer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_FormulaOneRacer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1575
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_subsequentWork_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_subsequentWork_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_subsequentWork" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_subsequentWork_delta_old" ON "dbrdf_subsequentWork_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_subsequentWork_delta_old" ON "dbrdf_subsequentWork_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_subsequentWork_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1576
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_orderInOffice_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_orderInOffice_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_orderInOffice" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_orderInOffice_delta_old" ON "dbrdf_orderInOffice_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_orderInOffice_delta_old" ON "dbrdf_orderInOffice_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_orderInOffice_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1577
    ---- DEPENDS ON: 759, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/NationalCollegiateAthleticAssociationAthlete>(?X) :- <http://dbpedia.org/ontology/formerHighschool>(?X,?X1) .
    INSERT INTO "dbrdf_NationalCollegiateAthleticAssociationAthlete"(s) SELECT DISTINCT t0.s FROM "dbrdf_formerHighschool" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_NationalCollegiateAthleticAssociationAthlete" 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_NationalCollegiateAthleticAssociationAthlete_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_NationalCollegiateAthleticAssociationAthlete_delta_old"(s) SELECT t0.s FROM "dbrdf_NationalCollegiateAthleticAssociationAthlete" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_NationalCollegiateAthleticAssociationAthlete_delta_old" ON "dbrdf_NationalCollegiateAthleticAssociationAthlete_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_NationalCollegiateAthleticAssociationAthlete_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/NationalCollegiateAthleticAssociationAthlete$delta_new>(?Y) :- <http://dbpedia.org/ontology/NationalCollegiateAthleticAssociationAthlete$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_NationalCollegiateAthleticAssociationAthlete_delta_new"(s) SELECT t1.o FROM "dbrdf_NationalCollegiateAthleticAssociationAthlete_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_NationalCollegiateAthleticAssociationAthlete" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_NationalCollegiateAthleticAssociationAthlete"(s) SELECT DISTINCT t0.s FROM "dbrdf_NationalCollegiateAthleticAssociationAthlete_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_NationalCollegiateAthleticAssociationAthlete_delta_old";
        INSERT INTO "dbrdf_NationalCollegiateAthleticAssociationAthlete_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_NationalCollegiateAthleticAssociationAthlete_delta_new" t0;
        TRUNCATE TABLE "dbrdf_NationalCollegiateAthleticAssociationAthlete_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1578
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_finalFlight_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_finalFlight_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_finalFlight" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_finalFlight_delta_old" ON "dbrdf_finalFlight_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_finalFlight_delta_old" ON "dbrdf_finalFlight_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_finalFlight_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1579
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfEntrances_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfEntrances_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfEntrances" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfEntrances_delta_old" ON "dbrdf_numberOfEntrances_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfEntrances_delta_old" ON "dbrdf_numberOfEntrances_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfEntrances_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1580
    ---- DEPENDS ON: 1579, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Cave>(?X) :- <http://dbpedia.org/ontology/numberOfEntrances>(?X,?X1) .
    INSERT INTO "dbrdf_Cave"(s) SELECT DISTINCT t0.s FROM "dbrdf_numberOfEntrances" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Cave" 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_Cave_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Cave_delta_old"(s) SELECT t0.s FROM "dbrdf_Cave" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Cave_delta_old" ON "dbrdf_Cave_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Cave_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/Cave$delta_new>(?Y) :- <http://dbpedia.org/ontology/Cave$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Cave_delta_new"(s) SELECT t1.o FROM "dbrdf_Cave_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Cave" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Cave"(s) SELECT DISTINCT t0.s FROM "dbrdf_Cave_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Cave_delta_old";
        INSERT INTO "dbrdf_Cave_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Cave_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Cave_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1581
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_facilityId_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_facilityId_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_facilityId" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_facilityId_delta_old" ON "dbrdf_facilityId_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_facilityId_delta_old" ON "dbrdf_facilityId_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_facilityId_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1582
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_depth_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_depth_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_depth" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_depth_delta_old" ON "dbrdf_depth_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_depth_delta_old" ON "dbrdf_depth_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_depth_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1583
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_airportUsing_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_airportUsing_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_airportUsing" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_airportUsing_delta_old" ON "dbrdf_airportUsing_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_airportUsing_delta_old" ON "dbrdf_airportUsing_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_airportUsing_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1584
    ---- DEPENDS ON: 1583, 1327, 1257, 999, 928, 712, 453, 326, 173, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Airport>(?X) :- <http://dbpedia.org/ontology/runwayLength>(?X,?X1) .
    INSERT INTO "dbrdf_Airport0"(s) SELECT DISTINCT t0.s FROM "dbrdf_runwayLength" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Airport0" 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_Airport_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Airport_delta_old"(s) SELECT t0.s FROM "dbrdf_Airport" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Airport_delta_old" ON "dbrdf_Airport_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Airport_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Airport_delta_old0"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Airport_delta_old0"(s) SELECT t0.s FROM "dbrdf_Airport0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Airport_delta_old0" ON "dbrdf_Airport_delta_old0"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Airport_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/Airport$delta_new>(?X) :- <http://dbpedia.org/ontology/Airport$delta_old>(?X) .
        INSERT INTO "dbrdf_Airport_delta_new"(s) SELECT t0.s FROM "dbrdf_Airport_delta_old0" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Airport" ex WHERE ex.s = t0.s);


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


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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Airport"(s) SELECT DISTINCT t0.s FROM "dbrdf_Airport_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Airport_delta_old";
        INSERT INTO "dbrdf_Airport_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Airport_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Airport_delta_new";

        INSERT INTO "dbrdf_Airport0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Airport_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_Airport_delta_old0";
        INSERT INTO "dbrdf_Airport_delta_old0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Airport_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_Airport_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1585
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_runtime_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_runtime_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_runtime0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_runtime_delta_old0" ON "dbrdf_runtime_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_runtime_delta_old0" ON "dbrdf_runtime_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_runtime_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/runtime$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/runtime$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_runtime_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_runtime_delta_old0" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_runtime0" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_runtime0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_runtime_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_runtime_delta_old0";
        INSERT INTO "dbrdf_runtime_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_runtime_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_runtime_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1586
    ---- DEPENDS ON: 1394, 1218, 941, 557, 339, 43, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Album>(?X1) :- <http://dbpedia.org/ontology/album>(?X,?X1) .
    INSERT INTO "dbrdf_Album"(s) SELECT DISTINCT t0.o FROM "dbrdf_album" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Album" ex WHERE ex.s = 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_Album_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Album_delta_old"(s) SELECT t0.s FROM "dbrdf_Album" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Album_delta_old" ON "dbrdf_Album_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Album_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_MusicAlbum_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_MusicAlbum_delta_old"(s) SELECT t0.s FROM "dbrdf_MusicAlbum" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_MusicAlbum_delta_old" ON "dbrdf_MusicAlbum_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_MusicAlbum_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/Album$delta_new>(?X) :- <http://schema.org/MusicAlbum$delta_old>(?X) .
        INSERT INTO "dbrdf_Album_delta_new"(s) SELECT t0.s FROM "dbrdf_MusicAlbum_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Album" ex WHERE ex.s = t0.s);


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


        -- <http://schema.org/MusicAlbum$delta_new>(?X) :- <http://dbpedia.org/ontology/Album$delta_old>(?X) .
        INSERT INTO "dbrdf_MusicAlbum_delta_new"(s) SELECT t0.s FROM "dbrdf_Album_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_MusicAlbum" ex WHERE ex.s = t0.s);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Album"(s) SELECT DISTINCT t0.s FROM "dbrdf_Album_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Album_delta_old";
        INSERT INTO "dbrdf_Album_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Album_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Album_delta_new";

        INSERT INTO "dbrdf_MusicAlbum"(s) SELECT DISTINCT t0.s FROM "dbrdf_MusicAlbum_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_MusicAlbum_delta_old";
        INSERT INTO "dbrdf_MusicAlbum_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_MusicAlbum_delta_new" t0;
        TRUNCATE TABLE "dbrdf_MusicAlbum_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1587
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_governorGeneral_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_governorGeneral_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_governorGeneral" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_governorGeneral_delta_old" ON "dbrdf_governorGeneral_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_governorGeneral_delta_old" ON "dbrdf_governorGeneral_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_governorGeneral_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1588
    ---- DEPENDS ON: 502, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/SportsTeamSeason>(?X) :- <http://dbpedia.org/ontology/SoccerClubSeason>(?X) .
    INSERT INTO "dbrdf_SportsTeamSeason"(s) SELECT t0.s FROM "dbrdf_SoccerClubSeason" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_SportsTeamSeason" 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_SportsTeamSeason_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SportsTeamSeason_delta_old"(s) SELECT t0.s FROM "dbrdf_SportsTeamSeason" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SportsTeamSeason_delta_old" ON "dbrdf_SportsTeamSeason_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SportsTeamSeason_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/SportsTeamSeason$delta_new>(?Y) :- <http://dbpedia.org/ontology/SportsTeamSeason$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_SportsTeamSeason_delta_new"(s) SELECT t1.o FROM "dbrdf_SportsTeamSeason_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_SportsTeamSeason" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_SportsTeamSeason"(s) SELECT DISTINCT t0.s FROM "dbrdf_SportsTeamSeason_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SportsTeamSeason_delta_old";
        INSERT INTO "dbrdf_SportsTeamSeason_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SportsTeamSeason_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SportsTeamSeason_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1589
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_teamName_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_teamName_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_teamName" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_teamName_delta_old" ON "dbrdf_teamName_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_teamName_delta_old" ON "dbrdf_teamName_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_teamName_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1590
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_spacecraft_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_spacecraft_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_spacecraft" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_spacecraft_delta_old" ON "dbrdf_spacecraft_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_spacecraft_delta_old" ON "dbrdf_spacecraft_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_spacecraft_delta_new"(s integer, o 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$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/spacecraft$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_spacecraft_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_spacecraft_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_spacecraft" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1591
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_averageClassSize_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_averageClassSize_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_averageClassSize" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_averageClassSize_delta_old" ON "dbrdf_averageClassSize_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_averageClassSize_delta_old" ON "dbrdf_averageClassSize_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_averageClassSize_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1592
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_fuelSystem_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_fuelSystem_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_fuelSystem" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_fuelSystem_delta_old" ON "dbrdf_fuelSystem_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_fuelSystem_delta_old" ON "dbrdf_fuelSystem_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_fuelSystem_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1593
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_reopened_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_reopened_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_reopened" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_reopened_delta_old" ON "dbrdf_reopened_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_reopened_delta_old" ON "dbrdf_reopened_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_reopened_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1594
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_games_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_games_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_games" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_games_delta_old" ON "dbrdf_games_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_games_delta_old" ON "dbrdf_games_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_games_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1595
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_boilerPressure_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_boilerPressure_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_boilerPressure" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_boilerPressure_delta_old" ON "dbrdf_boilerPressure_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_boilerPressure_delta_old" ON "dbrdf_boilerPressure_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_boilerPressure_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1596
    ---- DEPENDS ON: 1595, 701, 539, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

    -- [Rule] <http://dbpedia.org/ontology/Locomotive>(?X) :- <http://dbpedia.org/ontology/cylinderCount>(?X,?X1) .
    INSERT INTO "dbrdf_Locomotive"(s) SELECT DISTINCT t0.s FROM "dbrdf_cylinderCount" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Locomotive" 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_Locomotive_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Locomotive_delta_old"(s) SELECT t0.s FROM "dbrdf_Locomotive" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Locomotive_delta_old" ON "dbrdf_Locomotive_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Locomotive_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/Locomotive$delta_new>(?Y) :- <http://dbpedia.org/ontology/Locomotive$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Locomotive_delta_new"(s) SELECT t1.o FROM "dbrdf_Locomotive_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Locomotive" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Locomotive"(s) SELECT DISTINCT t0.s FROM "dbrdf_Locomotive_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Locomotive_delta_old";
        INSERT INTO "dbrdf_Locomotive_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Locomotive_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Locomotive_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1597
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfPages_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfPages_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfPages" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfPages_delta_old" ON "dbrdf_numberOfPages_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfPages_delta_old" ON "dbrdf_numberOfPages_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfPages_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1598
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_openingYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_openingYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_openingYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_openingYear_delta_old" ON "dbrdf_openingYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_openingYear_delta_old" ON "dbrdf_openingYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_openingYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1599
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_suborbitalFlights_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_suborbitalFlights_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_suborbitalFlights" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_suborbitalFlights_delta_old" ON "dbrdf_suborbitalFlights_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_suborbitalFlights_delta_old" ON "dbrdf_suborbitalFlights_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_suborbitalFlights_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1600
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfSports_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfSports_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfSports" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfSports_delta_old" ON "dbrdf_numberOfSports_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfSports_delta_old" ON "dbrdf_numberOfSports_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfSports_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1601
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_otherWins_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_otherWins_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_otherWins" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_otherWins_delta_old" ON "dbrdf_otherWins_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_otherWins_delta_old" ON "dbrdf_otherWins_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_otherWins_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1602
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstAscentYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstAscentYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_firstAscentYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstAscentYear_delta_old" ON "dbrdf_firstAscentYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstAscentYear_delta_old" ON "dbrdf_firstAscentYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstAscentYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1603
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_compressionRatio_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_compressionRatio_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_compressionRatio" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_compressionRatio_delta_old" ON "dbrdf_compressionRatio_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_compressionRatio_delta_old" ON "dbrdf_compressionRatio_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_compressionRatio_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1604
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_frequentlyUpdated_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_frequentlyUpdated_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_frequentlyUpdated" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_frequentlyUpdated_delta_old" ON "dbrdf_frequentlyUpdated_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_frequentlyUpdated_delta_old" ON "dbrdf_frequentlyUpdated_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_frequentlyUpdated_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1605
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectCoordinator_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_projectCoordinator_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_projectCoordinator" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_projectCoordinator_delta_old" ON "dbrdf_projectCoordinator_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_projectCoordinator_delta_old" ON "dbrdf_projectCoordinator_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectCoordinator_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1606
    ---- DEPENDS ON: 1605, 1533, 1418, 931, 901, 810, 544, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/ResearchProject>(?X) :- <http://dbpedia.org/ontology/projectParticipant>(?X,?X1) .
    INSERT INTO "dbrdf_ResearchProject"(s) SELECT DISTINCT t0.s FROM "dbrdf_projectParticipant" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_ResearchProject" 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_ResearchProject_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ResearchProject_delta_old"(s) SELECT t0.s FROM "dbrdf_ResearchProject" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ResearchProject_delta_old" ON "dbrdf_ResearchProject_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ResearchProject_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/ResearchProject$delta_new>(?Y) :- <http://dbpedia.org/ontology/ResearchProject$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_ResearchProject_delta_new"(s) SELECT t1.o FROM "dbrdf_ResearchProject_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_ResearchProject" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_ResearchProject"(s) SELECT DISTINCT t0.s FROM "dbrdf_ResearchProject_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_ResearchProject_delta_old";
        INSERT INTO "dbrdf_ResearchProject_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_ResearchProject_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ResearchProject_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1607
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_poleDriver_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_poleDriver_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_poleDriver" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_poleDriver_delta_old" ON "dbrdf_poleDriver_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_poleDriver_delta_old" ON "dbrdf_poleDriver_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_poleDriver_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1608
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_wheelbase_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_wheelbase_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_wheelbase0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_wheelbase_delta_old0" ON "dbrdf_wheelbase_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_wheelbase_delta_old0" ON "dbrdf_wheelbase_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_wheelbase_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/Automobile/wheelbase$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Automobile/wheelbase$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_wheelbase_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_wheelbase_delta_old0" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_wheelbase0" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_wheelbase0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_wheelbase_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_wheelbase_delta_old0";
        INSERT INTO "dbrdf_wheelbase_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_wheelbase_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_wheelbase_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1609
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_reportingMark_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_reportingMark_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_reportingMark" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_reportingMark_delta_old" ON "dbrdf_reportingMark_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_reportingMark_delta_old" ON "dbrdf_reportingMark_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_reportingMark_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1610
    ---- DEPENDS ON: 1609, 1181, 651, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

    -- [Rule] <http://dbpedia.org/ontology/PublicTransitSystem>(?X) :- <http://dbpedia.org/ontology/reportingMark>(?X,?X1) .
    INSERT INTO "dbrdf_PublicTransitSystem"(s) SELECT DISTINCT t0.s FROM "dbrdf_reportingMark" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_PublicTransitSystem" 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_PublicTransitSystem_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_PublicTransitSystem_delta_old"(s) SELECT t0.s FROM "dbrdf_PublicTransitSystem" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_PublicTransitSystem_delta_old" ON "dbrdf_PublicTransitSystem_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_PublicTransitSystem_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/PublicTransitSystem$delta_new>(?Y) :- <http://dbpedia.org/ontology/PublicTransitSystem$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_PublicTransitSystem_delta_new"(s) SELECT t1.o FROM "dbrdf_PublicTransitSystem_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_PublicTransitSystem" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_PublicTransitSystem"(s) SELECT DISTINCT t0.s FROM "dbrdf_PublicTransitSystem_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_PublicTransitSystem_delta_old";
        INSERT INTO "dbrdf_PublicTransitSystem_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_PublicTransitSystem_delta_new" t0;
        TRUNCATE TABLE "dbrdf_PublicTransitSystem_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1611
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_locatedInArea_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_locatedInArea_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_locatedInArea" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_locatedInArea_delta_old" ON "dbrdf_locatedInArea_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_locatedInArea_delta_old" ON "dbrdf_locatedInArea_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_locatedInArea_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1612
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_id_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_id_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_id" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_id_delta_old" ON "dbrdf_id_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_id_delta_old" ON "dbrdf_id_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_id_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1613
    ---- DEPENDS ON: 1612, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/WorldHeritageSite>(?X) :- <http://dbpedia.org/ontology/id>(?X,?X1) .
    INSERT INTO "dbrdf_WorldHeritageSite"(s) SELECT DISTINCT t0.s FROM "dbrdf_id" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_WorldHeritageSite" 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_WorldHeritageSite_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_WorldHeritageSite_delta_old"(s) SELECT t0.s FROM "dbrdf_WorldHeritageSite" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_WorldHeritageSite_delta_old" ON "dbrdf_WorldHeritageSite_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_WorldHeritageSite_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/WorldHeritageSite$delta_new>(?Y) :- <http://dbpedia.org/ontology/WorldHeritageSite$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_WorldHeritageSite_delta_new"(s) SELECT t1.o FROM "dbrdf_WorldHeritageSite_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_WorldHeritageSite" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_WorldHeritageSite"(s) SELECT DISTINCT t0.s FROM "dbrdf_WorldHeritageSite_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_WorldHeritageSite_delta_old";
        INSERT INTO "dbrdf_WorldHeritageSite_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_WorldHeritageSite_delta_new" t0;
        TRUNCATE TABLE "dbrdf_WorldHeritageSite_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1614
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_relation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_relation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_relation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_relation_delta_old" ON "dbrdf_relation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_relation_delta_old" ON "dbrdf_relation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_relation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1615
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_university_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_university_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_university" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_university_delta_old" ON "dbrdf_university_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_university_delta_old" ON "dbrdf_university_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_university_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1616
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_englishName_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_englishName_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_englishName" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_englishName_delta_old" ON "dbrdf_englishName_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_englishName_delta_old" ON "dbrdf_englishName_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_englishName_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1617
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_chain_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_chain_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_chain" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_chain_delta_old" ON "dbrdf_chain_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_chain_delta_old" ON "dbrdf_chain_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_chain_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1618
    ---- DEPENDS ON: 1617, 1344, 1223, 1151, 378, 338, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Hotel>(?X) :- <http://dbpedia.org/ontology/numberOfSuites>(?X,?X1) .
    INSERT INTO "dbrdf_Hotel0"(s) SELECT DISTINCT t0.s FROM "dbrdf_numberOfSuites" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Hotel0" 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_Hotel_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Hotel_delta_old"(s) SELECT t0.s FROM "dbrdf_Hotel" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Hotel_delta_old" ON "dbrdf_Hotel_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Hotel_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Hotel_delta_old0"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Hotel_delta_old0"(s) SELECT t0.s FROM "dbrdf_Hotel0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Hotel_delta_old0" ON "dbrdf_Hotel_delta_old0"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Hotel_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/Hotel$delta_new>(?X) :- <http://dbpedia.org/ontology/Hotel$delta_old>(?X) .
        INSERT INTO "dbrdf_Hotel_delta_new"(s) SELECT t0.s FROM "dbrdf_Hotel_delta_old0" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Hotel" ex WHERE ex.s = t0.s);


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


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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Hotel"(s) SELECT DISTINCT t0.s FROM "dbrdf_Hotel_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Hotel_delta_old";
        INSERT INTO "dbrdf_Hotel_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Hotel_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Hotel_delta_new";

        INSERT INTO "dbrdf_Hotel0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Hotel_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_Hotel_delta_old0";
        INSERT INTO "dbrdf_Hotel_delta_old0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Hotel_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_Hotel_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1619
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_geneLocation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_geneLocation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_geneLocation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_geneLocation_delta_old" ON "dbrdf_geneLocation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_geneLocation_delta_old" ON "dbrdf_geneLocation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_geneLocation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1620
    ---- DEPENDS ON: 1619, 1221, 1129, 944, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

    -- [Rule] <http://dbpedia.org/ontology/Gene>(?X) :- <http://dbpedia.org/ontology/MouseGene>(?X) .
    INSERT INTO "dbrdf_Gene"(s) SELECT t0.s FROM "dbrdf_MouseGene" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Gene" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/Gene>(?X) :- <http://dbpedia.org/ontology/HumanGene>(?X) .
    INSERT INTO "dbrdf_Gene"(s) SELECT t0.s FROM "dbrdf_HumanGene" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Gene" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/Gene>(?X1) :- <http://dbpedia.org/ontology/orthologousGene>(?X,?X1) .
    INSERT INTO "dbrdf_Gene"(s) SELECT DISTINCT t0.o FROM "dbrdf_orthologousGene" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Gene" ex WHERE ex.s = 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_Gene_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Gene_delta_old"(s) SELECT t0.s FROM "dbrdf_Gene" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Gene_delta_old" ON "dbrdf_Gene_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Gene_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/Gene$delta_new>(?Y) :- <http://dbpedia.org/ontology/Gene$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Gene_delta_new"(s) SELECT t1.o FROM "dbrdf_Gene_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Gene" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Gene"(s) SELECT DISTINCT t0.s FROM "dbrdf_Gene_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Gene_delta_old";
        INSERT INTO "dbrdf_Gene_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Gene_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Gene_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1621
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_neighboringMunicipality_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_neighboringMunicipality_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_neighboringMunicipality" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_neighboringMunicipality_delta_old" ON "dbrdf_neighboringMunicipality_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_neighboringMunicipality_delta_old" ON "dbrdf_neighboringMunicipality_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_neighboringMunicipality_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1622
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ethnicGroup_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ethnicGroup_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_ethnicGroup" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ethnicGroup_delta_old" ON "dbrdf_ethnicGroup_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ethnicGroup_delta_old" ON "dbrdf_ethnicGroup_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ethnicGroup_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1623
    ---- DEPENDS ON: 1622, 1105, 748, 246, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/EthnicGroup>(?X1) :- <http://dbpedia.org/ontology/ethnicity>(?X,?X1) .
    INSERT INTO "dbrdf_EthnicGroup"(s) SELECT DISTINCT t0.o FROM "dbrdf_ethnicity" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_EthnicGroup" ex WHERE ex.s = 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_EthnicGroup_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_EthnicGroup_delta_old"(s) SELECT t0.s FROM "dbrdf_EthnicGroup" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_EthnicGroup_delta_old" ON "dbrdf_EthnicGroup_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_EthnicGroup_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/EthnicGroup$delta_new>(?Y) :- <http://dbpedia.org/ontology/EthnicGroup$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_EthnicGroup_delta_new"(s) SELECT t1.o FROM "dbrdf_EthnicGroup_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_EthnicGroup" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_EthnicGroup"(s) SELECT DISTINCT t0.s FROM "dbrdf_EthnicGroup_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_EthnicGroup_delta_old";
        INSERT INTO "dbrdf_EthnicGroup_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_EthnicGroup_delta_new" t0;
        TRUNCATE TABLE "dbrdf_EthnicGroup_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1624
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtJLPGA_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtJLPGA_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_winsAtJLPGA" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtJLPGA_delta_old" ON "dbrdf_winsAtJLPGA_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtJLPGA_delta_old" ON "dbrdf_winsAtJLPGA_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtJLPGA_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1625
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_constellation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_constellation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_constellation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_constellation_delta_old" ON "dbrdf_constellation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_constellation_delta_old" ON "dbrdf_constellation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_constellation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1626
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_functionEndYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_functionEndYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_functionEndYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_functionEndYear_delta_old" ON "dbrdf_functionEndYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_functionEndYear_delta_old" ON "dbrdf_functionEndYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_functionEndYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1627
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_routeNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_routeNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_routeNumber" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_routeNumber_delta_old" ON "dbrdf_routeNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_routeNumber_delta_old" ON "dbrdf_routeNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_routeNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1628
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Surname_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Surname_delta_old"(s) SELECT t0.s FROM "dbrdf_Surname" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Surname_delta_old" ON "dbrdf_Surname_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Surname_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/Surname$delta_new>(?Y) :- <http://dbpedia.org/ontology/Surname$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Surname_delta_new"(s) SELECT t1.o FROM "dbrdf_Surname_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Surname" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Surname"(s) SELECT DISTINCT t0.s FROM "dbrdf_Surname_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Surname_delta_old";
        INSERT INTO "dbrdf_Surname_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Surname_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Surname_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1629
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_family_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_family_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_family" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_family_delta_old" ON "dbrdf_family_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_family_delta_old" ON "dbrdf_family_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_family_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1630
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumBoatBeam_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_maximumBoatBeam_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_maximumBoatBeam0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_maximumBoatBeam_delta_old0" ON "dbrdf_maximumBoatBeam_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_maximumBoatBeam_delta_old0" ON "dbrdf_maximumBoatBeam_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumBoatBeam_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/maximumBoatBeam$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/maximumBoatBeam$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_maximumBoatBeam_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_maximumBoatBeam_delta_old0" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_maximumBoatBeam0" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_maximumBoatBeam0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_maximumBoatBeam_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_maximumBoatBeam_delta_old0";
        INSERT INTO "dbrdf_maximumBoatBeam_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_maximumBoatBeam_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_maximumBoatBeam_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1631
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationUrban_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_populationUrban_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_populationUrban" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_populationUrban_delta_old" ON "dbrdf_populationUrban_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_populationUrban_delta_old" ON "dbrdf_populationUrban_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationUrban_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1632
    ---- DEPENDS ON: 1254, 734, 265, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

    -- [Rule] <http://dbpedia.org/ontology/Instrument>(?X1) :- <http://dbpedia.org/ontology/instrument>(?X,?X1) .
    INSERT INTO "dbrdf_Instrument"(s) SELECT DISTINCT t0.o FROM "dbrdf_instrument" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Instrument" ex WHERE ex.s = 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_Instrument_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Instrument_delta_old"(s) SELECT t0.s FROM "dbrdf_Instrument" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Instrument_delta_old" ON "dbrdf_Instrument_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Instrument_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/Instrument$delta_new>(?Y) :- <http://dbpedia.org/ontology/Instrument$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Instrument_delta_new"(s) SELECT t1.o FROM "dbrdf_Instrument_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Instrument" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Instrument"(s) SELECT DISTINCT t0.s FROM "dbrdf_Instrument_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Instrument_delta_old";
        INSERT INTO "dbrdf_Instrument_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Instrument_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Instrument_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1633
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_temperature_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_temperature_delta_old1"(s, o) SELECT t0.s, t0.o FROM "dbrdf_temperature1" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_temperature_delta_old1" ON "dbrdf_temperature_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_temperature_delta_old1" ON "dbrdf_temperature_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_temperature_delta_new1"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_temperature1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_temperature_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_temperature_delta_old1";
        INSERT INTO "dbrdf_temperature_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_temperature_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_temperature_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1634
    ---- DEPENDS ON: 1399, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/LunarCrater>(?X) :- <http://dbpedia.org/ontology/LunarCrater/diameter>(?X,?X1) .
    INSERT INTO "dbrdf_LunarCrater"(s) SELECT DISTINCT t0.s FROM "dbrdf_diameter2" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_LunarCrater" 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_LunarCrater_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_LunarCrater_delta_old"(s) SELECT t0.s FROM "dbrdf_LunarCrater" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_LunarCrater_delta_old" ON "dbrdf_LunarCrater_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_LunarCrater_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/LunarCrater$delta_new>(?Y) :- <http://dbpedia.org/ontology/LunarCrater$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_LunarCrater_delta_new"(s) SELECT t1.o FROM "dbrdf_LunarCrater_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_LunarCrater" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_LunarCrater"(s) SELECT DISTINCT t0.s FROM "dbrdf_LunarCrater_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_LunarCrater_delta_old";
        INSERT INTO "dbrdf_LunarCrater_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_LunarCrater_delta_new" t0;
        TRUNCATE TABLE "dbrdf_LunarCrater_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1635
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_homeStadium_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_homeStadium_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_homeStadium" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_homeStadium_delta_old" ON "dbrdf_homeStadium_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_homeStadium_delta_old" ON "dbrdf_homeStadium_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_homeStadium_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1636
    ---- DEPENDS ON: 1635, 917, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- [Rule] <http://dbpedia.org/ontology/Stadium>(?X1) :- <http://dbpedia.org/ontology/homeStadium>(?X,?X1) .
    INSERT INTO "dbrdf_Stadium"(s) SELECT DISTINCT t0.o FROM "dbrdf_homeStadium" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Stadium" ex WHERE ex.s = 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_Arena_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Arena_delta_old"(s) SELECT t0.s FROM "dbrdf_Arena" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Arena_delta_old" ON "dbrdf_Arena_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Arena_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_StadiumOrArena_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_StadiumOrArena_delta_old"(s) SELECT t0.s FROM "dbrdf_StadiumOrArena" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_StadiumOrArena_delta_old" ON "dbrdf_StadiumOrArena_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_StadiumOrArena_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Stadium_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Stadium_delta_old"(s) SELECT t0.s FROM "dbrdf_Stadium" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Stadium_delta_old" ON "dbrdf_Stadium_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Stadium_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/Arena$delta_new>(?X) :- <http://schema.org/StadiumOrArena$delta_old>(?X) .
        INSERT INTO "dbrdf_Arena_delta_new"(s) SELECT t0.s FROM "dbrdf_StadiumOrArena_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Arena" ex WHERE ex.s = t0.s);


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


        -- <http://schema.org/StadiumOrArena$delta_new>(?X) :- <http://dbpedia.org/ontology/Arena$delta_old>(?X) .
        INSERT INTO "dbrdf_StadiumOrArena_delta_new"(s) SELECT t0.s FROM "dbrdf_Arena_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_StadiumOrArena" ex WHERE ex.s = t0.s);


        -- <http://schema.org/StadiumOrArena$delta_new>(?X) :- <http://dbpedia.org/ontology/Stadium$delta_old>(?X) .
        INSERT INTO "dbrdf_StadiumOrArena_delta_new"(s) SELECT t0.s FROM "dbrdf_Stadium_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_StadiumOrArena" ex WHERE ex.s = t0.s);


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


        -- <http://dbpedia.org/ontology/Stadium$delta_new>(?X) :- <http://schema.org/StadiumOrArena$delta_old>(?X) .
        INSERT INTO "dbrdf_Stadium_delta_new"(s) SELECT t0.s FROM "dbrdf_StadiumOrArena_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Stadium" ex WHERE ex.s = t0.s);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Arena"(s) SELECT DISTINCT t0.s FROM "dbrdf_Arena_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Arena_delta_old";
        INSERT INTO "dbrdf_Arena_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Arena_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Arena_delta_new";

        INSERT INTO "dbrdf_StadiumOrArena"(s) SELECT DISTINCT t0.s FROM "dbrdf_StadiumOrArena_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_StadiumOrArena_delta_old";
        INSERT INTO "dbrdf_StadiumOrArena_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_StadiumOrArena_delta_new" t0;
        TRUNCATE TABLE "dbrdf_StadiumOrArena_delta_new";

        INSERT INTO "dbrdf_Stadium"(s) SELECT DISTINCT t0.s FROM "dbrdf_Stadium_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Stadium_delta_old";
        INSERT INTO "dbrdf_Stadium_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Stadium_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Stadium_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1637
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_automobileModel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_automobileModel_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_automobileModel" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_automobileModel_delta_old" ON "dbrdf_automobileModel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_automobileModel_delta_old" ON "dbrdf_automobileModel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_automobileModel_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1638
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_composer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_composer_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_composer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_composer_delta_old" ON "dbrdf_composer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_composer_delta_old" ON "dbrdf_composer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_composer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1639
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cargoFuel_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cargoFuel_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_cargoFuel0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cargoFuel_delta_old0" ON "dbrdf_cargoFuel_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_cargoFuel_delta_old0" ON "dbrdf_cargoFuel_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cargoFuel_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_cargoFuel0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cargoFuel_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_cargoFuel_delta_old0";
        INSERT INTO "dbrdf_cargoFuel_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cargoFuel_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_cargoFuel_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1640
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_producer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_producer_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_producer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_producer_delta_old" ON "dbrdf_producer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_producer_delta_old" ON "dbrdf_producer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_producer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1641
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_destructionDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_destructionDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_destructionDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_destructionDate_delta_old" ON "dbrdf_destructionDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_destructionDate_delta_old" ON "dbrdf_destructionDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_destructionDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1642
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_floorArea_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_floorArea_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_floorArea" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_floorArea_delta_old" ON "dbrdf_floorArea_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_floorArea_delta_old" ON "dbrdf_floorArea_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_floorArea_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1643
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_interest_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_interest_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_interest" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_interest_delta_old" ON "dbrdf_interest_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_interest_delta_old" ON "dbrdf_interest_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_interest_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1644
    ---- DEPENDS ON: 1643, 1345, 914, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

    -- [Rule] <http://dbpedia.org/ontology/SiteOfSpecialScientificInterest>(?X) :- <http://dbpedia.org/ontology/areaOfSearch>(?X,?X1) .
    INSERT INTO "dbrdf_SiteOfSpecialScientificInterest"(s) SELECT DISTINCT t0.s FROM "dbrdf_areaOfSearch" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_SiteOfSpecialScientificInterest" 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_SiteOfSpecialScientificInterest_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SiteOfSpecialScientificInterest_delta_old"(s) SELECT t0.s FROM "dbrdf_SiteOfSpecialScientificInterest" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SiteOfSpecialScientificInterest_delta_old" ON "dbrdf_SiteOfSpecialScientificInterest_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SiteOfSpecialScientificInterest_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/SiteOfSpecialScientificInterest$delta_new>(?Y) :- <http://dbpedia.org/ontology/SiteOfSpecialScientificInterest$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_SiteOfSpecialScientificInterest_delta_new"(s) SELECT t1.o FROM "dbrdf_SiteOfSpecialScientificInterest_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_SiteOfSpecialScientificInterest" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_SiteOfSpecialScientificInterest"(s) SELECT DISTINCT t0.s FROM "dbrdf_SiteOfSpecialScientificInterest_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SiteOfSpecialScientificInterest_delta_old";
        INSERT INTO "dbrdf_SiteOfSpecialScientificInterest_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SiteOfSpecialScientificInterest_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SiteOfSpecialScientificInterest_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1645
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_secondLeader_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_secondLeader_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_secondLeader" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_secondLeader_delta_old" ON "dbrdf_secondLeader_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_secondLeader_delta_old" ON "dbrdf_secondLeader_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_secondLeader_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1646
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceConfluencePosition_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sourceConfluencePosition_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_sourceConfluencePosition" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sourceConfluencePosition_delta_old" ON "dbrdf_sourceConfluencePosition_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sourceConfluencePosition_delta_old" ON "dbrdf_sourceConfluencePosition_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceConfluencePosition_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1647
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerTeam_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_formerTeam_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_formerTeam" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_formerTeam_delta_old" ON "dbrdf_formerTeam_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_formerTeam_delta_old" ON "dbrdf_formerTeam_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerTeam_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1648
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nationality_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nationality_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_nationality" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nationality_delta_old" ON "dbrdf_nationality_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nationality_delta_old" ON "dbrdf_nationality_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nationality_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1649
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_routeEndLocation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_routeEndLocation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_routeEndLocation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_routeEndLocation_delta_old" ON "dbrdf_routeEndLocation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_routeEndLocation_delta_old" ON "dbrdf_routeEndLocation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_routeEndLocation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1650
    ---- DEPENDS ON: 1392, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/SportsTeamMember>(?X) :- <http://dbpedia.org/ontology/squadNumber>(?X,?X1) .
    INSERT INTO "dbrdf_SportsTeamMember"(s) SELECT DISTINCT t0.s FROM "dbrdf_squadNumber" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_SportsTeamMember" 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_SportsTeamMember_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SportsTeamMember_delta_old"(s) SELECT t0.s FROM "dbrdf_SportsTeamMember" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SportsTeamMember_delta_old" ON "dbrdf_SportsTeamMember_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SportsTeamMember_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/SportsTeamMember$delta_new>(?Y) :- <http://dbpedia.org/ontology/SportsTeamMember$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_SportsTeamMember_delta_new"(s) SELECT t1.o FROM "dbrdf_SportsTeamMember_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_SportsTeamMember" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_SportsTeamMember"(s) SELECT DISTINCT t0.s FROM "dbrdf_SportsTeamMember_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SportsTeamMember_delta_old";
        INSERT INTO "dbrdf_SportsTeamMember_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SportsTeamMember_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SportsTeamMember_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1651
    ---- DEPENDS ON: 1650, 1337, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/OrganisationMember>(?X) :- <http://dbpedia.org/ontology/SportsTeamMember>(?X) .
    INSERT INTO "dbrdf_OrganisationMember"(s) SELECT t0.s FROM "dbrdf_SportsTeamMember" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_OrganisationMember" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/OrganisationMember>(?X1) :- <http://dbpedia.org/ontology/organisationMember>(?X,?X1) .
    INSERT INTO "dbrdf_OrganisationMember"(s) SELECT DISTINCT t0.o FROM "dbrdf_organisationMember" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_OrganisationMember" ex WHERE ex.s = 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_OrganisationMember_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_OrganisationMember_delta_old"(s) SELECT t0.s FROM "dbrdf_OrganisationMember" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_OrganisationMember_delta_old" ON "dbrdf_OrganisationMember_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_OrganisationMember_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/OrganisationMember$delta_new>(?Y) :- <http://dbpedia.org/ontology/OrganisationMember$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_OrganisationMember_delta_new"(s) SELECT t1.o FROM "dbrdf_OrganisationMember_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_OrganisationMember" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_OrganisationMember"(s) SELECT DISTINCT t0.s FROM "dbrdf_OrganisationMember_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_OrganisationMember_delta_old";
        INSERT INTO "dbrdf_OrganisationMember_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_OrganisationMember_delta_new" t0;
        TRUNCATE TABLE "dbrdf_OrganisationMember_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1652
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_accessDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_accessDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_accessDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_accessDate_delta_old" ON "dbrdf_accessDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_accessDate_delta_old" ON "dbrdf_accessDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_accessDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1653
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_goalsInLeague_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_goalsInLeague_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_goalsInLeague" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_goalsInLeague_delta_old" ON "dbrdf_goalsInLeague_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_goalsInLeague_delta_old" ON "dbrdf_goalsInLeague_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_goalsInLeague_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1654
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_chaplain_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_chaplain_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_chaplain" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_chaplain_delta_old" ON "dbrdf_chaplain_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_chaplain_delta_old" ON "dbrdf_chaplain_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_chaplain_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1655
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_network_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_network_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_network" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_network_delta_old" ON "dbrdf_network_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_network_delta_old" ON "dbrdf_network_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_network_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1656
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_municipalityType_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_municipalityType_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_municipalityType" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_municipalityType_delta_old" ON "dbrdf_municipalityType_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_municipalityType_delta_old" ON "dbrdf_municipalityType_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_municipalityType_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1657
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfPlatformLevels_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfPlatformLevels_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfPlatformLevels" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfPlatformLevels_delta_old" ON "dbrdf_numberOfPlatformLevels_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfPlatformLevels_delta_old" ON "dbrdf_numberOfPlatformLevels_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfPlatformLevels_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1658
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_closingDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_closingDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_closingDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_closingDate_delta_old" ON "dbrdf_closingDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_closingDate_delta_old" ON "dbrdf_closingDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_closingDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1659
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_genomeDB_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_genomeDB_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_genomeDB" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_genomeDB_delta_old" ON "dbrdf_genomeDB_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_genomeDB_delta_old" ON "dbrdf_genomeDB_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_genomeDB_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1660
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_endangeredSince_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_endangeredSince_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_endangeredSince" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_endangeredSince_delta_old" ON "dbrdf_endangeredSince_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_endangeredSince_delta_old" ON "dbrdf_endangeredSince_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_endangeredSince_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1661
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_geminiAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_geminiAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_geminiAward" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_geminiAward_delta_old" ON "dbrdf_geminiAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_geminiAward_delta_old" ON "dbrdf_geminiAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_geminiAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1662
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nationalYears_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nationalYears_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_nationalYears" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nationalYears_delta_old" ON "dbrdf_nationalYears_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nationalYears_delta_old" ON "dbrdf_nationalYears_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nationalYears_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1663
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_shareSource_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_shareSource_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_shareSource" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_shareSource_delta_old" ON "dbrdf_shareSource_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_shareSource_delta_old" ON "dbrdf_shareSource_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_shareSource_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1664
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_summerAppearances_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_summerAppearances_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_summerAppearances" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_summerAppearances_delta_old" ON "dbrdf_summerAppearances_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_summerAppearances_delta_old" ON "dbrdf_summerAppearances_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_summerAppearances_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- <http://dbpedia.org/ontology/summerAppearances$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/summerAppearances$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
