        INSERT INTO "dbrdf_discoverer_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_discoverer_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_discoverer" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1173
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_icd9_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_icd9_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_icd9" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_icd9_delta_old" ON "dbrdf_icd9_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_icd9_delta_old" ON "dbrdf_icd9_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_icd9_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1174
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_BaseballTeam"(s) SELECT DISTINCT t0.s FROM "dbrdf_BaseballTeam_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_BaseballTeam_delta_old";
        INSERT INTO "dbrdf_BaseballTeam_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_BaseballTeam_delta_new" t0;
        TRUNCATE TABLE "dbrdf_BaseballTeam_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1175
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Non_ProfitOrganisation"(s) SELECT DISTINCT t0.s FROM "dbrdf_Non_ProfitOrganisation_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Non_ProfitOrganisation_delta_old";
        INSERT INTO "dbrdf_Non_ProfitOrganisation_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Non_ProfitOrganisation_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Non_ProfitOrganisation_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1176
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_meshNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_meshNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_meshNumber" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_meshNumber_delta_old" ON "dbrdf_meshNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_meshNumber_delta_old" ON "dbrdf_meshNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_meshNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1177
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_emedicineTopic_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_emedicineTopic_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_emedicineTopic" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_emedicineTopic_delta_old" ON "dbrdf_emedicineTopic_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_emedicineTopic_delta_old" ON "dbrdf_emedicineTopic_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_emedicineTopic_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1178
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_geology_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_geology_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_geology" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_geology_delta_old" ON "dbrdf_geology_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_geology_delta_old" ON "dbrdf_geology_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_geology_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1179
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_distributingCompany_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_distributingCompany_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_distributingCompany" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_distributingCompany_delta_old" ON "dbrdf_distributingCompany_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_distributingCompany_delta_old" ON "dbrdf_distributingCompany_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_distributingCompany_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1180
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftHelicopterAttack_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftHelicopterAttack_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_aircraftHelicopterAttack" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftHelicopterAttack_delta_old" ON "dbrdf_aircraftHelicopterAttack_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftHelicopterAttack_delta_old" ON "dbrdf_aircraftHelicopterAttack_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftHelicopterAttack_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1181
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfLines_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfLines_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfLines" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfLines_delta_old" ON "dbrdf_numberOfLines_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfLines_delta_old" ON "dbrdf_numberOfLines_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfLines_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1182
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rgbCoordinateRed_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rgbCoordinateRed_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_rgbCoordinateRed" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rgbCoordinateRed_delta_old" ON "dbrdf_rgbCoordinateRed_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rgbCoordinateRed_delta_old" ON "dbrdf_rgbCoordinateRed_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rgbCoordinateRed_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1183
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationAsOf_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_populationAsOf_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_populationAsOf" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_populationAsOf_delta_old" ON "dbrdf_populationAsOf_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_populationAsOf_delta_old" ON "dbrdf_populationAsOf_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationAsOf_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1184
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_associatedRocket_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_associatedRocket_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_associatedRocket" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_associatedRocket_delta_old" ON "dbrdf_associatedRocket_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_associatedRocket_delta_old" ON "dbrdf_associatedRocket_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_associatedRocket_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1185
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_currentTeamMember_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_currentTeamMember_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_currentTeamMember" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_currentTeamMember_delta_old" ON "dbrdf_currentTeamMember_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_currentTeamMember_delta_old" ON "dbrdf_currentTeamMember_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_currentTeamMember_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1186
    ---- DEPENDS ON: 1185, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/TeamMember>(?X1) :- <http://dbpedia.org/ontology/currentTeamMember>(?X,?X1) .
    INSERT INTO "dbrdf_TeamMember"(s) SELECT DISTINCT t0.o FROM "dbrdf_currentTeamMember" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_TeamMember" 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_TeamMember_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_TeamMember_delta_old"(s) SELECT t0.s FROM "dbrdf_TeamMember" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_TeamMember_delta_old" ON "dbrdf_TeamMember_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_TeamMember_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/TeamMember$delta_new>(?Y) :- <http://dbpedia.org/ontology/TeamMember$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_TeamMember_delta_new"(s) SELECT t1.o FROM "dbrdf_TeamMember_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_TeamMember" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_TeamMember"(s) SELECT DISTINCT t0.s FROM "dbrdf_TeamMember_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_TeamMember_delta_old";
        INSERT INTO "dbrdf_TeamMember_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_TeamMember_delta_new" t0;
        TRUNCATE TABLE "dbrdf_TeamMember_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1187
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_legislativePeriodName_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_legislativePeriodName_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_legislativePeriodName" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_legislativePeriodName_delta_old" ON "dbrdf_legislativePeriodName_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_legislativePeriodName_delta_old" ON "dbrdf_legislativePeriodName_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_legislativePeriodName_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1188
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_religiousHeadLabel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_religiousHeadLabel_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_religiousHeadLabel" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_religiousHeadLabel_delta_old" ON "dbrdf_religiousHeadLabel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_religiousHeadLabel_delta_old" ON "dbrdf_religiousHeadLabel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_religiousHeadLabel_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1189
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_hasNaturalBust_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_hasNaturalBust_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_hasNaturalBust" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_hasNaturalBust_delta_old" ON "dbrdf_hasNaturalBust_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_hasNaturalBust_delta_old" ON "dbrdf_hasNaturalBust_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_hasNaturalBust_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1190
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_torqueOutput_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_torqueOutput_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_torqueOutput0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_torqueOutput_delta_old0" ON "dbrdf_torqueOutput_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_torqueOutput_delta_old0" ON "dbrdf_torqueOutput_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_torqueOutput_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_torqueOutput0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_torqueOutput_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_torqueOutput_delta_old0";
        INSERT INTO "dbrdf_torqueOutput_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_torqueOutput_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_torqueOutput_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1191
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_orbits_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_orbits_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_orbits" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_orbits_delta_old" ON "dbrdf_orbits_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_orbits_delta_old" ON "dbrdf_orbits_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_orbits_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1192
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_prospectLeague_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_prospectLeague_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_prospectLeague" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_prospectLeague_delta_old" ON "dbrdf_prospectLeague_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_prospectLeague_delta_old" ON "dbrdf_prospectLeague_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_prospectLeague_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1193
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_geneLocationStart_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_geneLocationStart_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_geneLocationStart" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_geneLocationStart_delta_old" ON "dbrdf_geneLocationStart_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_geneLocationStart_delta_old" ON "dbrdf_geneLocationStart_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_geneLocationStart_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1194
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aspectRatio_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aspectRatio_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_aspectRatio" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aspectRatio_delta_old" ON "dbrdf_aspectRatio_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aspectRatio_delta_old" ON "dbrdf_aspectRatio_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aspectRatio_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1195
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_BasketballTeam"(s) SELECT DISTINCT t0.s FROM "dbrdf_BasketballTeam_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_BasketballTeam_delta_old";
        INSERT INTO "dbrdf_BasketballTeam_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_BasketballTeam_delta_new" t0;
        TRUNCATE TABLE "dbrdf_BasketballTeam_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1196
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_schoolBoard_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_schoolBoard_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_schoolBoard" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_schoolBoard_delta_old" ON "dbrdf_schoolBoard_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_schoolBoard_delta_old" ON "dbrdf_schoolBoard_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_schoolBoard_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1197
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstFlightEndDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstFlightEndDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_firstFlightEndDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstFlightEndDate_delta_old" ON "dbrdf_firstFlightEndDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstFlightEndDate_delta_old" ON "dbrdf_firstFlightEndDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstFlightEndDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1198
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_bowlRecord_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_bowlRecord_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_bowlRecord" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_bowlRecord_delta_old" ON "dbrdf_bowlRecord_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_bowlRecord_delta_old" ON "dbrdf_bowlRecord_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_bowlRecord_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1199
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_landingDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_landingDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_landingDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_landingDate_delta_old" ON "dbrdf_landingDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_landingDate_delta_old" ON "dbrdf_landingDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_landingDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1200
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rival_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rival_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_rival" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rival_delta_old" ON "dbrdf_rival_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rival_delta_old" ON "dbrdf_rival_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rival_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1201
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_stateDelegate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_stateDelegate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_stateDelegate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_stateDelegate_delta_old" ON "dbrdf_stateDelegate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_stateDelegate_delta_old" ON "dbrdf_stateDelegate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_stateDelegate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1202
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_originalEndPoint_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_originalEndPoint_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_originalEndPoint" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_originalEndPoint_delta_old" ON "dbrdf_originalEndPoint_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_originalEndPoint_delta_old" ON "dbrdf_originalEndPoint_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_originalEndPoint_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1203
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfLaps_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfLaps_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfLaps" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfLaps_delta_old" ON "dbrdf_numberOfLaps_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfLaps_delta_old" ON "dbrdf_numberOfLaps_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfLaps_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1204
    ---- DEPENDS ON: 1203, 955, 434, 431, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/FormulaOneRacing>(?X) :- <http://dbpedia.org/ontology/circuitName>(?X,?X1) .
    INSERT INTO "dbrdf_FormulaOneRacing"(s) SELECT DISTINCT t0.s FROM "dbrdf_circuitName" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_FormulaOneRacing" 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_FormulaOneRacing_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_FormulaOneRacing_delta_old"(s) SELECT t0.s FROM "dbrdf_FormulaOneRacing" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_FormulaOneRacing_delta_old" ON "dbrdf_FormulaOneRacing_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_FormulaOneRacing_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/FormulaOneRacing$delta_new>(?Y) :- <http://dbpedia.org/ontology/FormulaOneRacing$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_FormulaOneRacing_delta_new"(s) SELECT t1.o FROM "dbrdf_FormulaOneRacing_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_FormulaOneRacing" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_FormulaOneRacing"(s) SELECT DISTINCT t0.s FROM "dbrdf_FormulaOneRacing_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_FormulaOneRacing_delta_old";
        INSERT INTO "dbrdf_FormulaOneRacing_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_FormulaOneRacing_delta_new" t0;
        TRUNCATE TABLE "dbrdf_FormulaOneRacing_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1205
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rankingsDoubles_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rankingsDoubles_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_rankingsDoubles" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rankingsDoubles_delta_old" ON "dbrdf_rankingsDoubles_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rankingsDoubles_delta_old" ON "dbrdf_rankingsDoubles_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rankingsDoubles_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1206
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_effectiveRadiatedPower_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_effectiveRadiatedPower_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_effectiveRadiatedPower" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_effectiveRadiatedPower_delta_old" ON "dbrdf_effectiveRadiatedPower_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_effectiveRadiatedPower_delta_old" ON "dbrdf_effectiveRadiatedPower_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_effectiveRadiatedPower_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1207
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_birthName_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_birthName_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_birthName" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_birthName_delta_old" ON "dbrdf_birthName_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_birthName_delta_old" ON "dbrdf_birthName_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_birthName_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1208
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_port1DockingDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_port1DockingDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_port1DockingDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_port1DockingDate_delta_old" ON "dbrdf_port1DockingDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_port1DockingDate_delta_old" ON "dbrdf_port1DockingDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_port1DockingDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1209
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_lunarSurfaceTime0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lunarSurfaceTime_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_lunarSurfaceTime_delta_old0";
        INSERT INTO "dbrdf_lunarSurfaceTime_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lunarSurfaceTime_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_lunarSurfaceTime_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1210
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_drainsTo_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_drainsTo_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_drainsTo" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_drainsTo_delta_old" ON "dbrdf_drainsTo_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_drainsTo_delta_old" ON "dbrdf_drainsTo_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_drainsTo_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1211
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_opponent_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_opponent_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_opponent" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_opponent_delta_old" ON "dbrdf_opponent_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_opponent_delta_old" ON "dbrdf_opponent_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_opponent_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1212
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_league_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_league_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_league" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_league_delta_old" ON "dbrdf_league_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_league_delta_old" ON "dbrdf_league_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_league_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1213
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_addressInRoad_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_addressInRoad_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_addressInRoad" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_addressInRoad_delta_old" ON "dbrdf_addressInRoad_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_addressInRoad_delta_old" ON "dbrdf_addressInRoad_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_addressInRoad_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1214
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_analogChannel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_analogChannel_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_analogChannel" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_analogChannel_delta_old" ON "dbrdf_analogChannel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_analogChannel_delta_old" ON "dbrdf_analogChannel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_analogChannel_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1215
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_regionServed_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_regionServed_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_regionServed" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_regionServed_delta_old" ON "dbrdf_regionServed_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_regionServed_delta_old" ON "dbrdf_regionServed_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_regionServed_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1216
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nonFictionSubject_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nonFictionSubject_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_nonFictionSubject" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nonFictionSubject_delta_old" ON "dbrdf_nonFictionSubject_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nonFictionSubject_delta_old" ON "dbrdf_nonFictionSubject_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nonFictionSubject_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1217
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_owner_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_owner_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_owner" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_owner_delta_old" ON "dbrdf_owner_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_owner_delta_old" ON "dbrdf_owner_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_owner_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1218
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_totalDiscs_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_totalDiscs_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_totalDiscs" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_totalDiscs_delta_old" ON "dbrdf_totalDiscs_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_totalDiscs_delta_old" ON "dbrdf_totalDiscs_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_totalDiscs_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1219
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_demographicsAsOf_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_demographicsAsOf_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_demographicsAsOf" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_demographicsAsOf_delta_old" ON "dbrdf_demographicsAsOf_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_demographicsAsOf_delta_old" ON "dbrdf_demographicsAsOf_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_demographicsAsOf_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1220
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_frequencyOfPublication_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_frequencyOfPublication_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_frequencyOfPublication" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_frequencyOfPublication_delta_old" ON "dbrdf_frequencyOfPublication_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_frequencyOfPublication_delta_old" ON "dbrdf_frequencyOfPublication_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_frequencyOfPublication_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1221
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_orthologousGene_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_orthologousGene_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_orthologousGene" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_orthologousGene_delta_old" ON "dbrdf_orthologousGene_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_orthologousGene_delta_old" ON "dbrdf_orthologousGene_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_orthologousGene_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1222
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfStations_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfStations_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfStations" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfStations_delta_old" ON "dbrdf_numberOfStations_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfStations_delta_old" ON "dbrdf_numberOfStations_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfStations_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1223
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfRestaurants_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfRestaurants_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfRestaurants" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfRestaurants_delta_old" ON "dbrdf_numberOfRestaurants_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfRestaurants_delta_old" ON "dbrdf_numberOfRestaurants_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfRestaurants_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1224
    ---- DEPENDS ON: 865, 825, 21, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

    -- [Rule] <http://dbpedia.org/ontology/AdministrativeRegion>(?X) :- <http://dbpedia.org/ontology/congressionalDistrict>(?X,?X1) .
    INSERT INTO "dbrdf_AdministrativeRegion"(s) SELECT DISTINCT t0.s FROM "dbrdf_congressionalDistrict" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_AdministrativeRegion" 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_AdministrativeRegion_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_AdministrativeRegion_delta_old"(s) SELECT t0.s FROM "dbrdf_AdministrativeRegion" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_AdministrativeRegion_delta_old" ON "dbrdf_AdministrativeRegion_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_AdministrativeRegion_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_AdministrativeArea_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_AdministrativeArea_delta_old"(s) SELECT t0.s FROM "dbrdf_AdministrativeArea" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_AdministrativeArea_delta_old" ON "dbrdf_AdministrativeArea_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_AdministrativeArea_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/AdministrativeRegion$delta_new>(?X) :- <http://schema.org/AdministrativeArea$delta_old>(?X) .
        INSERT INTO "dbrdf_AdministrativeRegion_delta_new"(s) SELECT t0.s FROM "dbrdf_AdministrativeArea_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_AdministrativeRegion" ex WHERE ex.s = t0.s);


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


        -- <http://schema.org/AdministrativeArea$delta_new>(?X) :- <http://dbpedia.org/ontology/AdministrativeRegion$delta_old>(?X) .
        INSERT INTO "dbrdf_AdministrativeArea_delta_new"(s) SELECT t0.s FROM "dbrdf_AdministrativeRegion_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_AdministrativeArea" ex WHERE ex.s = t0.s);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_AdministrativeRegion"(s) SELECT DISTINCT t0.s FROM "dbrdf_AdministrativeRegion_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_AdministrativeRegion_delta_old";
        INSERT INTO "dbrdf_AdministrativeRegion_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_AdministrativeRegion_delta_new" t0;
        TRUNCATE TABLE "dbrdf_AdministrativeRegion_delta_new";

        INSERT INTO "dbrdf_AdministrativeArea"(s) SELECT DISTINCT t0.s FROM "dbrdf_AdministrativeArea_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_AdministrativeArea_delta_old";
        INSERT INTO "dbrdf_AdministrativeArea_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_AdministrativeArea_delta_new" t0;
        TRUNCATE TABLE "dbrdf_AdministrativeArea_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1225
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerChannel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_formerChannel_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_formerChannel" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_formerChannel_delta_old" ON "dbrdf_formerChannel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_formerChannel_delta_old" ON "dbrdf_formerChannel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerChannel_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1226
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_unitCost_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_unitCost_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_unitCost" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_unitCost_delta_old" ON "dbrdf_unitCost_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_unitCost_delta_old" ON "dbrdf_unitCost_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_unitCost_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1227
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_meetingCity_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_meetingCity_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_meetingCity" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_meetingCity_delta_old" ON "dbrdf_meetingCity_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_meetingCity_delta_old" ON "dbrdf_meetingCity_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_meetingCity_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1228
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rightTributary_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rightTributary_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_rightTributary" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rightTributary_delta_old" ON "dbrdf_rightTributary_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rightTributary_delta_old" ON "dbrdf_rightTributary_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rightTributary_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1229
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_satellite_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_satellite_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_satellite" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_satellite_delta_old" ON "dbrdf_satellite_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_satellite_delta_old" ON "dbrdf_satellite_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_satellite_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1230
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfPeopleAttending_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfPeopleAttending_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfPeopleAttending" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfPeopleAttending_delta_old" ON "dbrdf_numberOfPeopleAttending_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfPeopleAttending_delta_old" ON "dbrdf_numberOfPeopleAttending_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfPeopleAttending_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1231
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_highschool_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_highschool_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_highschool" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_highschool_delta_old" ON "dbrdf_highschool_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_highschool_delta_old" ON "dbrdf_highschool_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_highschool_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1232
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_part_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_part_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_part" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_part_delta_old" ON "dbrdf_part_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_part_delta_old" ON "dbrdf_part_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_part_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1233
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_island_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_island_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_island" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_island_delta_old" ON "dbrdf_island_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_island_delta_old" ON "dbrdf_island_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_island_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1234
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftBomber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftBomber_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_aircraftBomber" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftBomber_delta_old" ON "dbrdf_aircraftBomber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftBomber_delta_old" ON "dbrdf_aircraftBomber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftBomber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1235
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_dryCargo0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_dryCargo_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_dryCargo_delta_old0";
        INSERT INTO "dbrdf_dryCargo_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_dryCargo_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_dryCargo_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1236
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lessPopulatedCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lessPopulatedCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lessPopulatedCountry" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lessPopulatedCountry_delta_old" ON "dbrdf_lessPopulatedCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lessPopulatedCountry_delta_old" ON "dbrdf_lessPopulatedCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lessPopulatedCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1237
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_award_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_award_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_award" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_award_delta_old" ON "dbrdf_award_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_award_delta_old" ON "dbrdf_award_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_award_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1238
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_riverBranch_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_riverBranch_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_riverBranch" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_riverBranch_delta_old" ON "dbrdf_riverBranch_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_riverBranch_delta_old" ON "dbrdf_riverBranch_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_riverBranch_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1239
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_spacewalkEnd_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_spacewalkEnd_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_spacewalkEnd" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_spacewalkEnd_delta_old" ON "dbrdf_spacewalkEnd_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_spacewalkEnd_delta_old" ON "dbrdf_spacewalkEnd_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_spacewalkEnd_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1240
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_highestMountain_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_highestMountain_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_highestMountain" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_highestMountain_delta_old" ON "dbrdf_highestMountain_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_highestMountain_delta_old" ON "dbrdf_highestMountain_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_highestMountain_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1241
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_worstDefeat_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_worstDefeat_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_worstDefeat" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_worstDefeat_delta_old" ON "dbrdf_worstDefeat_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_worstDefeat_delta_old" ON "dbrdf_worstDefeat_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_worstDefeat_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1242
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_thirdTeam_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_thirdTeam_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_thirdTeam" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_thirdTeam_delta_old" ON "dbrdf_thirdTeam_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_thirdTeam_delta_old" ON "dbrdf_thirdTeam_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_thirdTeam_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1243
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_cargoGas0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cargoGas_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_cargoGas_delta_old0";
        INSERT INTO "dbrdf_cargoGas_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cargoGas_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_cargoGas_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1244
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_border_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_border_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_border" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_border_delta_old" ON "dbrdf_border_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_border_delta_old" ON "dbrdf_border_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_border_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1245
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfVisitorsAsOf_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfVisitorsAsOf_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfVisitorsAsOf" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfVisitorsAsOf_delta_old" ON "dbrdf_numberOfVisitorsAsOf_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfVisitorsAsOf_delta_old" ON "dbrdf_numberOfVisitorsAsOf_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfVisitorsAsOf_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1246
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_diameter1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_diameter_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_diameter_delta_old1";
        INSERT INTO "dbrdf_diameter_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_diameter_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_diameter_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1247
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cpu_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cpu_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_cpu" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cpu_delta_old" ON "dbrdf_cpu_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_cpu_delta_old" ON "dbrdf_cpu_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cpu_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1248
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_beatifiedDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_beatifiedDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_beatifiedDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_beatifiedDate_delta_old" ON "dbrdf_beatifiedDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_beatifiedDate_delta_old" ON "dbrdf_beatifiedDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_beatifiedDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1249
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_populationMetroDensity0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_populationMetroDensity_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_populationMetroDensity_delta_old0";
        INSERT INTO "dbrdf_populationMetroDensity_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_populationMetroDensity_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_populationMetroDensity_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1250
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_organSystem_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_organSystem_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_organSystem" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_organSystem_delta_old" ON "dbrdf_organSystem_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_organSystem_delta_old" ON "dbrdf_organSystem_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_organSystem_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1251
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_totalMass0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_totalMass_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_totalMass_delta_old0";
        INSERT INTO "dbrdf_totalMass_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_totalMass_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_totalMass_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1252
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_areaMetro0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_areaMetro_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_areaMetro_delta_old0";
        INSERT INTO "dbrdf_areaMetro_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_areaMetro_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_areaMetro_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1253
    ---- DEPENDS ON: 1252, 333, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- [Rule] <http://dbpedia.org/ontology/GeopoliticalOrganisation>(?X) :- <http://dbpedia.org/ontology/GeopoliticalOrganisation/populationDensity>(?X,?X1) .
    INSERT INTO "dbrdf_GeopoliticalOrganisation"(s) SELECT DISTINCT t0.s FROM "dbrdf_populationDensity" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_GeopoliticalOrganisation" 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_GeopoliticalOrganisation_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_GeopoliticalOrganisation_delta_old"(s) SELECT t0.s FROM "dbrdf_GeopoliticalOrganisation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_GeopoliticalOrganisation_delta_old" ON "dbrdf_GeopoliticalOrganisation_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_GeopoliticalOrganisation_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/GeopoliticalOrganisation$delta_new>(?Y) :- <http://dbpedia.org/ontology/GeopoliticalOrganisation$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_GeopoliticalOrganisation_delta_new"(s) SELECT t1.o FROM "dbrdf_GeopoliticalOrganisation_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_GeopoliticalOrganisation" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_GeopoliticalOrganisation"(s) SELECT DISTINCT t0.s FROM "dbrdf_GeopoliticalOrganisation_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_GeopoliticalOrganisation_delta_old";
        INSERT INTO "dbrdf_GeopoliticalOrganisation_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_GeopoliticalOrganisation_delta_new" t0;
        TRUNCATE TABLE "dbrdf_GeopoliticalOrganisation_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1254
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_instrument_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_instrument_delta_old"(s, o) SELECT t0.s, t0.o 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, o); CREATE INDEX "IDX_1_dbrdf_instrument_delta_old" ON "dbrdf_instrument_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_instrument_delta_new"(s integer, o 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,?X1) :- <http://dbpedia.org/ontology/instrument$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_instrument_delta_new"(s, o) SELECT t1.o, t0.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 AND ex.o = t0.o);


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1255
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_block_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_block_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_block" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_block_delta_old" ON "dbrdf_block_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_block_delta_old" ON "dbrdf_block_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_block_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1256
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_gross_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_gross_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_gross" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_gross_delta_old" ON "dbrdf_gross_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_gross_delta_old" ON "dbrdf_gross_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_gross_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1257
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_faaLocationIdentifier_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_faaLocationIdentifier_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_faaLocationIdentifier" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_faaLocationIdentifier_delta_old" ON "dbrdf_faaLocationIdentifier_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_faaLocationIdentifier_delta_old" ON "dbrdf_faaLocationIdentifier_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_faaLocationIdentifier_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1258
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_leaderFunction_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_leaderFunction_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_leaderFunction" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_leaderFunction_delta_old" ON "dbrdf_leaderFunction_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_leaderFunction_delta_old" ON "dbrdf_leaderFunction_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_leaderFunction_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1259
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_serviceModule_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_serviceModule_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_serviceModule" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_serviceModule_delta_old" ON "dbrdf_serviceModule_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_serviceModule_delta_old" ON "dbrdf_serviceModule_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_serviceModule_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1260
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_administrator_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_administrator_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_administrator" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_administrator_delta_old" ON "dbrdf_administrator_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_administrator_delta_old" ON "dbrdf_administrator_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_administrator_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1261
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aSide_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aSide_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_aSide" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aSide_delta_old" ON "dbrdf_aSide_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aSide_delta_old" ON "dbrdf_aSide_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aSide_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1262
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstAscentPerson_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstAscentPerson_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_firstAscentPerson" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstAscentPerson_delta_old" ON "dbrdf_firstAscentPerson_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstAscentPerson_delta_old" ON "dbrdf_firstAscentPerson_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstAscentPerson_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1263
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaUrban_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_areaUrban_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_areaUrban" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_areaUrban_delta_old" ON "dbrdf_areaUrban_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_areaUrban_delta_old" ON "dbrdf_areaUrban_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaUrban_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1264
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_CanadianFootballTeam"(s) SELECT DISTINCT t0.s FROM "dbrdf_CanadianFootballTeam_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_CanadianFootballTeam_delta_old";
        INSERT INTO "dbrdf_CanadianFootballTeam_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_CanadianFootballTeam_delta_new" t0;
        TRUNCATE TABLE "dbrdf_CanadianFootballTeam_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1265
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_escapeVelocity_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_escapeVelocity_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_escapeVelocity" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_escapeVelocity_delta_old" ON "dbrdf_escapeVelocity_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_escapeVelocity_delta_old" ON "dbrdf_escapeVelocity_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_escapeVelocity_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1266
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_style_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_style_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_style" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_style_delta_old" ON "dbrdf_style_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_style_delta_old" ON "dbrdf_style_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_style_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1267
    ---- DEPENDS ON: 1266, 454, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- [Rule] <http://dbpedia.org/ontology/Painting>(?X) :- <http://dbpedia.org/ontology/technique>(?X,?X1) .
    INSERT INTO "dbrdf_Painting0"(s) SELECT DISTINCT t0.s FROM "dbrdf_technique" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Painting0" 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_Painting_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Painting_delta_old"(s) SELECT t0.s FROM "dbrdf_Painting" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Painting_delta_old" ON "dbrdf_Painting_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Painting_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Painting_delta_old0"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Painting_delta_old0"(s) SELECT t0.s FROM "dbrdf_Painting0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Painting_delta_old0" ON "dbrdf_Painting_delta_old0"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Painting_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/Painting$delta_new>(?X) :- <http://dbpedia.org/ontology/Painting$delta_old>(?X) .
        INSERT INTO "dbrdf_Painting_delta_new"(s) SELECT t0.s FROM "dbrdf_Painting_delta_old0" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Painting" ex WHERE ex.s = t0.s);


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


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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Painting"(s) SELECT DISTINCT t0.s FROM "dbrdf_Painting_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Painting_delta_old";
        INSERT INTO "dbrdf_Painting_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Painting_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Painting_delta_new";

        INSERT INTO "dbrdf_Painting0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Painting_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_Painting_delta_old0";
        INSERT INTO "dbrdf_Painting_delta_old0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Painting_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_Painting_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1268
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_goyaAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_goyaAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_goyaAward" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_goyaAward_delta_old" ON "dbrdf_goyaAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_goyaAward_delta_old" ON "dbrdf_goyaAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_goyaAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1269
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_isPartOfAnatomicalStructure_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_isPartOfAnatomicalStructure_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_isPartOfAnatomicalStructure" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_isPartOfAnatomicalStructure_delta_old" ON "dbrdf_isPartOfAnatomicalStructure_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_isPartOfAnatomicalStructure_delta_old" ON "dbrdf_isPartOfAnatomicalStructure_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_isPartOfAnatomicalStructure_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1270
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_approximateCalories_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_approximateCalories_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_approximateCalories" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_approximateCalories_delta_old" ON "dbrdf_approximateCalories_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_approximateCalories_delta_old" ON "dbrdf_approximateCalories_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_approximateCalories_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1271
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_custodian_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_custodian_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_custodian" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_custodian_delta_old" ON "dbrdf_custodian_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_custodian_delta_old" ON "dbrdf_custodian_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_custodian_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1272
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfSpans_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfSpans_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfSpans" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfSpans_delta_old" ON "dbrdf_numberOfSpans_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfSpans_delta_old" ON "dbrdf_numberOfSpans_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfSpans_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1273
    ---- DEPENDS ON: 1272, 1037, 902, 518, 255, 224, 210, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Bridge>(?X) :- <http://dbpedia.org/ontology/crosses>(?X,?X1) .
    INSERT INTO "dbrdf_Bridge"(s) SELECT DISTINCT t0.s FROM "dbrdf_crosses" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Bridge" 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_Bridge_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Bridge_delta_old"(s) SELECT t0.s FROM "dbrdf_Bridge" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Bridge_delta_old" ON "dbrdf_Bridge_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Bridge_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/Bridge$delta_new>(?Y) :- <http://dbpedia.org/ontology/Bridge$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Bridge_delta_new"(s) SELECT t1.o FROM "dbrdf_Bridge_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Bridge" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Bridge"(s) SELECT DISTINCT t0.s FROM "dbrdf_Bridge_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Bridge_delta_old";
        INSERT INTO "dbrdf_Bridge_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Bridge_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Bridge_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1274
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sportCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sportCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_sportCountry" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sportCountry_delta_old" ON "dbrdf_sportCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sportCountry_delta_old" ON "dbrdf_sportCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sportCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1275
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_grossDomesticProductAsOf_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_grossDomesticProductAsOf_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_grossDomesticProductAsOf" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_grossDomesticProductAsOf_delta_old" ON "dbrdf_grossDomesticProductAsOf_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_grossDomesticProductAsOf_delta_old" ON "dbrdf_grossDomesticProductAsOf_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_grossDomesticProductAsOf_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1276
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_fuelCapacity0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_fuelCapacity_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_fuelCapacity_delta_old0";
        INSERT INTO "dbrdf_fuelCapacity_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_fuelCapacity_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_fuelCapacity_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1277
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Park_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Park_delta_old"(s) SELECT t0.s FROM "dbrdf_Park" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Park_delta_old" ON "dbrdf_Park_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Park_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Park_delta_old0"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Park_delta_old0"(s) SELECT t0.s FROM "dbrdf_Park0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Park_delta_old0" ON "dbrdf_Park_delta_old0"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Park_delta_new0"(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/Park$delta_new>(?X) :- <http://schema.org/Park$delta_old>(?X) .
        INSERT INTO "dbrdf_Park_delta_new"(s) SELECT t0.s FROM "dbrdf_Park_delta_old0" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Park" ex WHERE ex.s = t0.s);


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


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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Park"(s) SELECT DISTINCT t0.s FROM "dbrdf_Park_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Park_delta_old";
        INSERT INTO "dbrdf_Park_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Park_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Park_delta_new";

        INSERT INTO "dbrdf_Park0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Park_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_Park_delta_old0";
        INSERT INTO "dbrdf_Park_delta_old0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Park_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_Park_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1278
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_areaUrban0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_areaUrban_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_areaUrban_delta_old0";
        INSERT INTO "dbrdf_areaUrban_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_areaUrban_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_areaUrban_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1279
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_iso31661Code_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_iso31661Code_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_iso31661Code" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_iso31661Code_delta_old" ON "dbrdf_iso31661Code_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_iso31661Code_delta_old" ON "dbrdf_iso31661Code_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_iso31661Code_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1280
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_tuition_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_tuition_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_tuition" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_tuition_delta_old" ON "dbrdf_tuition_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_tuition_delta_old" ON "dbrdf_tuition_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_tuition_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1281
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfGraduateStudents_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfGraduateStudents_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfGraduateStudents" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfGraduateStudents_delta_old" ON "dbrdf_numberOfGraduateStudents_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfGraduateStudents_delta_old" ON "dbrdf_numberOfGraduateStudents_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfGraduateStudents_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1282
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_monarch_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_monarch_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_monarch" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_monarch_delta_old" ON "dbrdf_monarch_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_monarch_delta_old" ON "dbrdf_monarch_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_monarch_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1283
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_port1UndockingDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_port1UndockingDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_port1UndockingDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_port1UndockingDate_delta_old" ON "dbrdf_port1UndockingDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_port1UndockingDate_delta_old" ON "dbrdf_port1UndockingDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_port1UndockingDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1284
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_schoolPatron_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_schoolPatron_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_schoolPatron" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_schoolPatron_delta_old" ON "dbrdf_schoolPatron_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_schoolPatron_delta_old" ON "dbrdf_schoolPatron_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_schoolPatron_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1285
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_notableStudent_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_notableStudent_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_notableStudent" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_notableStudent_delta_old" ON "dbrdf_notableStudent_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_notableStudent_delta_old" ON "dbrdf_notableStudent_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_notableStudent_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1286
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_occupation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_occupation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_occupation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_occupation_delta_old" ON "dbrdf_occupation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_occupation_delta_old" ON "dbrdf_occupation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_occupation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1287
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_language_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_language_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_language" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_language_delta_old" ON "dbrdf_language_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_language_delta_old" ON "dbrdf_language_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_language_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1288
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_profession_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_profession_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_profession" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_profession_delta_old" ON "dbrdf_profession_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_profession_delta_old" ON "dbrdf_profession_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_profession_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1289
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_voiceType_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_voiceType_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_voiceType" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_voiceType_delta_old" ON "dbrdf_voiceType_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_voiceType_delta_old" ON "dbrdf_voiceType_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_voiceType_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1290
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_highestBreak_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_highestBreak_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_highestBreak" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_highestBreak_delta_old" ON "dbrdf_highestBreak_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_highestBreak_delta_old" ON "dbrdf_highestBreak_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_highestBreak_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1291
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_startDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_startDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_startDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_startDate_delta_old" ON "dbrdf_startDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_startDate_delta_old" ON "dbrdf_startDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_startDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1292
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_partyNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_partyNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_partyNumber" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_partyNumber_delta_old" ON "dbrdf_partyNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_partyNumber_delta_old" ON "dbrdf_partyNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_partyNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1293
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_majorIsland_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_majorIsland_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_majorIsland" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_majorIsland_delta_old" ON "dbrdf_majorIsland_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_majorIsland_delta_old" ON "dbrdf_majorIsland_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_majorIsland_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1294
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Amphibian"(s) SELECT DISTINCT t0.s FROM "dbrdf_Amphibian_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Amphibian_delta_old";
        INSERT INTO "dbrdf_Amphibian_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Amphibian_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Amphibian_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1295
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_engine_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_engine_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_engine" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_engine_delta_old" ON "dbrdf_engine_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_engine_delta_old" ON "dbrdf_engine_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_engine_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1296
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_eruptionYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_eruptionYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_eruptionYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_eruptionYear_delta_old" ON "dbrdf_eruptionYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_eruptionYear_delta_old" ON "dbrdf_eruptionYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_eruptionYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1297
    ---- DEPENDS ON: 1296, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Volcano>(?X) :- <http://dbpedia.org/ontology/eruptionYear>(?X,?X1) .
    INSERT INTO "dbrdf_Volcano"(s) SELECT DISTINCT t0.s FROM "dbrdf_eruptionYear" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Volcano" 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_Volcano_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Volcano_delta_old"(s) SELECT t0.s FROM "dbrdf_Volcano" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Volcano_delta_old" ON "dbrdf_Volcano_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Volcano_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/Volcano$delta_new>(?Y) :- <http://dbpedia.org/ontology/Volcano$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Volcano_delta_new"(s) SELECT t1.o FROM "dbrdf_Volcano_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Volcano" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Volcano"(s) SELECT DISTINCT t0.s FROM "dbrdf_Volcano_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Volcano_delta_old";
        INSERT INTO "dbrdf_Volcano_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Volcano_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Volcano_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1298
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_administrativeDistrict_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_administrativeDistrict_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_administrativeDistrict" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_administrativeDistrict_delta_old" ON "dbrdf_administrativeDistrict_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_administrativeDistrict_delta_old" ON "dbrdf_administrativeDistrict_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_administrativeDistrict_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1299
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_visitorStatisticsAsOf_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_visitorStatisticsAsOf_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_visitorStatisticsAsOf" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_visitorStatisticsAsOf_delta_old" ON "dbrdf_visitorStatisticsAsOf_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_visitorStatisticsAsOf_delta_old" ON "dbrdf_visitorStatisticsAsOf_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_visitorStatisticsAsOf_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1300
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_SkiArea_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SkiArea_delta_old"(s) SELECT t0.s FROM "dbrdf_SkiArea" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SkiArea_delta_old" ON "dbrdf_SkiArea_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SkiArea_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SkiResort_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SkiResort_delta_old"(s) SELECT t0.s FROM "dbrdf_SkiResort" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SkiResort_delta_old" ON "dbrdf_SkiResort_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SkiResort_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/SkiArea$delta_new>(?X) :- <http://schema.org/SkiResort$delta_old>(?X) .
        INSERT INTO "dbrdf_SkiArea_delta_new"(s) SELECT t0.s FROM "dbrdf_SkiResort_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_SkiArea" ex WHERE ex.s = t0.s);


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


        -- <http://schema.org/SkiResort$delta_new>(?X) :- <http://dbpedia.org/ontology/SkiArea$delta_old>(?X) .
        INSERT INTO "dbrdf_SkiResort_delta_new"(s) SELECT t0.s FROM "dbrdf_SkiArea_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_SkiResort" ex WHERE ex.s = t0.s);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_SkiArea"(s) SELECT DISTINCT t0.s FROM "dbrdf_SkiArea_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SkiArea_delta_old";
        INSERT INTO "dbrdf_SkiArea_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SkiArea_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SkiArea_delta_new";

        INSERT INTO "dbrdf_SkiResort"(s) SELECT DISTINCT t0.s FROM "dbrdf_SkiResort_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SkiResort_delta_old";
        INSERT INTO "dbrdf_SkiResort_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SkiResort_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SkiResort_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1301
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_largestCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_largestCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_largestCountry" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_largestCountry_delta_old" ON "dbrdf_largestCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_largestCountry_delta_old" ON "dbrdf_largestCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_largestCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1302
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cmykCoordinateMagenta_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cmykCoordinateMagenta_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_cmykCoordinateMagenta" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cmykCoordinateMagenta_delta_old" ON "dbrdf_cmykCoordinateMagenta_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_cmykCoordinateMagenta_delta_old" ON "dbrdf_cmykCoordinateMagenta_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cmykCoordinateMagenta_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1303
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_periapsis_delta_old2"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_periapsis_delta_old2"(s, o) SELECT t0.s, t0.o FROM "dbrdf_periapsis2" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_periapsis_delta_old2" ON "dbrdf_periapsis_delta_old2"(s, o); CREATE INDEX "IDX_1_dbrdf_periapsis_delta_old2" ON "dbrdf_periapsis_delta_old2"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_periapsis_delta_new2"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1304
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_volume_delta_old2"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_volume_delta_old2"(s, o) SELECT t0.s, t0.o FROM "dbrdf_volume2" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_volume_delta_old2" ON "dbrdf_volume_delta_old2"(s, o); CREATE INDEX "IDX_1_dbrdf_volume_delta_old2" ON "dbrdf_volume_delta_old2"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_volume_delta_new2"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1305
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_capitalCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_capitalCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_capitalCountry" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_capitalCountry_delta_old" ON "dbrdf_capitalCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_capitalCountry_delta_old" ON "dbrdf_capitalCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_capitalCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1306
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lunarLandingSite_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lunarLandingSite_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lunarLandingSite" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lunarLandingSite_delta_old" ON "dbrdf_lunarLandingSite_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lunarLandingSite_delta_old" ON "dbrdf_lunarLandingSite_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lunarLandingSite_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1307
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dateExtended_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dateExtended_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_dateExtended" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dateExtended_delta_old" ON "dbrdf_dateExtended_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dateExtended_delta_old" ON "dbrdf_dateExtended_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dateExtended_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1308
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_port2DockingDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_port2DockingDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_port2DockingDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_port2DockingDate_delta_old" ON "dbrdf_port2DockingDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_port2DockingDate_delta_old" ON "dbrdf_port2DockingDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_port2DockingDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1309
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_soccerTournamentOpeningSeason_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_soccerTournamentOpeningSeason_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_soccerTournamentOpeningSeason" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_soccerTournamentOpeningSeason_delta_old" ON "dbrdf_soccerTournamentOpeningSeason_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_soccerTournamentOpeningSeason_delta_old" ON "dbrdf_soccerTournamentOpeningSeason_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_soccerTournamentOpeningSeason_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1310
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_usSales_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_usSales_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_usSales" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_usSales_delta_old" ON "dbrdf_usSales_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_usSales_delta_old" ON "dbrdf_usSales_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_usSales_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1311
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_hipSize_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_hipSize_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_hipSize" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_hipSize_delta_old" ON "dbrdf_hipSize_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_hipSize_delta_old" ON "dbrdf_hipSize_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_hipSize_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1312
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_executiveHeadteacher_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_executiveHeadteacher_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_executiveHeadteacher" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_executiveHeadteacher_delta_old" ON "dbrdf_executiveHeadteacher_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_executiveHeadteacher_delta_old" ON "dbrdf_executiveHeadteacher_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_executiveHeadteacher_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1313
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_startPoint_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_startPoint_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_startPoint" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_startPoint_delta_old" ON "dbrdf_startPoint_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_startPoint_delta_old" ON "dbrdf_startPoint_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_startPoint_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1314
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_dockedTime0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_dockedTime_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_dockedTime_delta_old0";
        INSERT INTO "dbrdf_dockedTime_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_dockedTime_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_dockedTime_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1315
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_superintendent_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_superintendent_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_superintendent" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_superintendent_delta_old" ON "dbrdf_superintendent_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_superintendent_delta_old" ON "dbrdf_superintendent_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_superintendent_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1316
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_latestPreviewVersion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_latestPreviewVersion_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_latestPreviewVersion" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_latestPreviewVersion_delta_old" ON "dbrdf_latestPreviewVersion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_latestPreviewVersion_delta_old" ON "dbrdf_latestPreviewVersion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_latestPreviewVersion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1317
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_course0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_course_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_course_delta_old0";
        INSERT INTO "dbrdf_course_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_course_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_course_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1318
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_serviceStartDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_serviceStartDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_serviceStartDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_serviceStartDate_delta_old" ON "dbrdf_serviceStartDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_serviceStartDate_delta_old" ON "dbrdf_serviceStartDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_serviceStartDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1319
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rightChild_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rightChild_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_rightChild" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rightChild_delta_old" ON "dbrdf_rightChild_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rightChild_delta_old" ON "dbrdf_rightChild_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rightChild_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1320
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaLand_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_areaLand_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_areaLand" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_areaLand_delta_old" ON "dbrdf_areaLand_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_areaLand_delta_old" ON "dbrdf_areaLand_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaLand_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1321
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfOrbits_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfOrbits_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfOrbits" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfOrbits_delta_old" ON "dbrdf_numberOfOrbits_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfOrbits_delta_old" ON "dbrdf_numberOfOrbits_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfOrbits_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1322
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_component_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_component_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_component" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_component_delta_old" ON "dbrdf_component_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_component_delta_old" ON "dbrdf_component_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_component_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1323
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_reopeningYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_reopeningYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_reopeningYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_reopeningYear_delta_old" ON "dbrdf_reopeningYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_reopeningYear_delta_old" ON "dbrdf_reopeningYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_reopeningYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1324
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_internationalAffiliation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_internationalAffiliation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_internationalAffiliation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_internationalAffiliation_delta_old" ON "dbrdf_internationalAffiliation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_internationalAffiliation_delta_old" ON "dbrdf_internationalAffiliation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_internationalAffiliation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1325
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_area0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_area_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_area_delta_old0";
        INSERT INTO "dbrdf_area_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_area_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_area_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1326
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_jstor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_jstor_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_jstor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_jstor_delta_old" ON "dbrdf_jstor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_jstor_delta_old" ON "dbrdf_jstor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_jstor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1327
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_runwayLength_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_runwayLength_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_runwayLength" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_runwayLength_delta_old" ON "dbrdf_runwayLength_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_runwayLength_delta_old" ON "dbrdf_runwayLength_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_runwayLength_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1328
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_distributor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_distributor_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_distributor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_distributor_delta_old" ON "dbrdf_distributor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_distributor_delta_old" ON "dbrdf_distributor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_distributor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1329
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationTotal_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_populationTotal_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_populationTotal" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_populationTotal_delta_old" ON "dbrdf_populationTotal_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_populationTotal_delta_old" ON "dbrdf_populationTotal_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationTotal_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1330
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winterAppearances_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winterAppearances_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_winterAppearances" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winterAppearances_delta_old" ON "dbrdf_winterAppearances_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winterAppearances_delta_old" ON "dbrdf_winterAppearances_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winterAppearances_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1331
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_bustSize_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_bustSize_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_bustSize" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_bustSize_delta_old" ON "dbrdf_bustSize_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_bustSize_delta_old" ON "dbrdf_bustSize_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_bustSize_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1332
    ---- DEPENDS ON: 1164, 1023, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- [Rule] <http://dbpedia.org/ontology/LawFirm>(?X) :- <http://dbpedia.org/ontology/numberOfLawyers>(?X,?X1) .
    INSERT INTO "dbrdf_LawFirm"(s) SELECT DISTINCT t0.s FROM "dbrdf_numberOfLawyers" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_LawFirm" 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_LawFirm_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_LawFirm_delta_old"(s) SELECT t0.s FROM "dbrdf_LawFirm" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_LawFirm_delta_old" ON "dbrdf_LawFirm_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_LawFirm_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/LawFirm$delta_new>(?Y) :- <http://dbpedia.org/ontology/LawFirm$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_LawFirm_delta_new"(s) SELECT t1.o FROM "dbrdf_LawFirm_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_LawFirm" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_LawFirm"(s) SELECT DISTINCT t0.s FROM "dbrdf_LawFirm_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_LawFirm_delta_old";
        INSERT INTO "dbrdf_LawFirm_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_LawFirm_delta_new" t0;
        TRUNCATE TABLE "dbrdf_LawFirm_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1333
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_hgncid_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_hgncid_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_hgncid" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_hgncid_delta_old" ON "dbrdf_hgncid_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_hgncid_delta_old" ON "dbrdf_hgncid_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_hgncid_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1334
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_battleHonours_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_battleHonours_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_battleHonours" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_battleHonours_delta_old" ON "dbrdf_battleHonours_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_battleHonours_delta_old" ON "dbrdf_battleHonours_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_battleHonours_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1335
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_person_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_person_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_person" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_person_delta_old" ON "dbrdf_person_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_person_delta_old" ON "dbrdf_person_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_person_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1336
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_measurements_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_measurements_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_measurements" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_measurements_delta_old" ON "dbrdf_measurements_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_measurements_delta_old" ON "dbrdf_measurements_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_measurements_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1337
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_organisationMember_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_organisationMember_delta_old"(s, o) SELECT t0.s, t0.o 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, o); CREATE INDEX "IDX_1_dbrdf_organisationMember_delta_old" ON "dbrdf_organisationMember_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_organisationMember_delta_new"(s integer, o 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,?X1) :- <http://dbpedia.org/ontology/organisationMember$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_organisationMember_delta_new"(s, o) SELECT t1.o, t0.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 AND ex.o = t0.o);


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1338
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_statisticLabel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_statisticLabel_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_statisticLabel" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_statisticLabel_delta_old" ON "dbrdf_statisticLabel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_statisticLabel_delta_old" ON "dbrdf_statisticLabel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_statisticLabel_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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