    CREATE LOCAL TEMPORARY TABLE "dbrdf_satScore_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_pseudonym_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_pseudonym_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_pseudonym" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_pseudonym_delta_old" ON "dbrdf_pseudonym_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_pseudonym_delta_old" ON "dbrdf_pseudonym_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_pseudonym_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_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 830
    ---- 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 831
    ---- DEPENDS ON: 577, 369, 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 832
    ---- 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 833
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 834
    ---- 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 835
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_TradeUnion"(s) SELECT DISTINCT t0.s FROM "dbrdf_TradeUnion_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_TradeUnion_delta_old";
        INSERT INTO "dbrdf_TradeUnion_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_TradeUnion_delta_new" t0;
        TRUNCATE TABLE "dbrdf_TradeUnion_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_capitalPosition_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_capitalPosition_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_capitalPosition" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_capitalPosition_delta_old" ON "dbrdf_capitalPosition_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_capitalPosition_delta_old" ON "dbrdf_capitalPosition_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_capitalPosition_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lymph_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lymph_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lymph" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lymph_delta_old" ON "dbrdf_lymph_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lymph_delta_old" ON "dbrdf_lymph_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lymph_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 838
    ---- DEPENDS ON: 837, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Lymph>(?X1) :- <http://dbpedia.org/ontology/lymph>(?X,?X1) .
    INSERT INTO "dbrdf_Lymph"(s) SELECT DISTINCT t0.o FROM "dbrdf_lymph" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Lymph" 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_Lymph_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Lymph_delta_old"(s) SELECT t0.s FROM "dbrdf_Lymph" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Lymph_delta_old" ON "dbrdf_Lymph_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Lymph_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/Lymph$delta_new>(?Y) :- <http://dbpedia.org/ontology/Lymph$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Lymph_delta_new"(s) SELECT t1.o FROM "dbrdf_Lymph_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Lymph" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Lymph"(s) SELECT DISTINCT t0.s FROM "dbrdf_Lymph_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Lymph_delta_old";
        INSERT INTO "dbrdf_Lymph_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Lymph_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Lymph_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_timeInSpace1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_timeInSpace_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_timeInSpace_delta_old1";
        INSERT INTO "dbrdf_timeInSpace_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_timeInSpace_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_timeInSpace_delta_new1";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_championships_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_championships_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_championships" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_championships_delta_old" ON "dbrdf_championships_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_championships_delta_old" ON "dbrdf_championships_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_championships_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_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 843
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_geneLocationEnd_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_geneLocationEnd_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_geneLocationEnd" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_geneLocationEnd_delta_old" ON "dbrdf_geneLocationEnd_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_geneLocationEnd_delta_old" ON "dbrdf_geneLocationEnd_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_geneLocationEnd_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_timeZone_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_timeZone_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_timeZone" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_timeZone_delta_old" ON "dbrdf_timeZone_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_timeZone_delta_old" ON "dbrdf_timeZone_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_timeZone_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 846
    ---- 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;
        TRUNCATE TABLE "dbrdf_statisticLabel_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 847
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_school_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_school_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_school" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_school_delta_old" ON "dbrdf_school_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_school_delta_old" ON "dbrdf_school_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_school_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_incumbent_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_incumbent_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_incumbent" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_incumbent_delta_old" ON "dbrdf_incumbent_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_incumbent_delta_old" ON "dbrdf_incumbent_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_incumbent_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nerve_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nerve_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_nerve" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nerve_delta_old" ON "dbrdf_nerve_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nerve_delta_old" ON "dbrdf_nerve_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nerve_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 850
    ---- DEPENDS ON: 849, 459, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- [Rule] <http://dbpedia.org/ontology/Nerve>(?X1) :- <http://dbpedia.org/ontology/nerve>(?X,?X1) .
    INSERT INTO "dbrdf_Nerve"(s) SELECT DISTINCT t0.o FROM "dbrdf_nerve" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Nerve" 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_Nerve_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Nerve_delta_old"(s) SELECT t0.s FROM "dbrdf_Nerve" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Nerve_delta_old" ON "dbrdf_Nerve_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Nerve_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/Nerve$delta_new>(?Y) :- <http://dbpedia.org/ontology/Nerve$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Nerve_delta_new"(s) SELECT t1.o FROM "dbrdf_Nerve_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Nerve" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Nerve"(s) SELECT DISTINCT t0.s FROM "dbrdf_Nerve_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Nerve_delta_old";
        INSERT INTO "dbrdf_Nerve_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Nerve_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Nerve_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_SpeedwayLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_SpeedwayLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SpeedwayLeague_delta_old";
        INSERT INTO "dbrdf_SpeedwayLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SpeedwayLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SpeedwayLeague_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_access_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_access_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_access" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_access_delta_old" ON "dbrdf_access_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_access_delta_old" ON "dbrdf_access_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_access_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerHighschool_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_formerHighschool_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_formerHighschool" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_formerHighschool_delta_old" ON "dbrdf_formerHighschool_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_formerHighschool_delta_old" ON "dbrdf_formerHighschool_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerHighschool_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfParkingSpaces_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfParkingSpaces_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfParkingSpaces" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfParkingSpaces_delta_old" ON "dbrdf_numberOfParkingSpaces_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfParkingSpaces_delta_old" ON "dbrdf_numberOfParkingSpaces_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfParkingSpaces_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_height2"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_height_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_height_delta_old2";
        INSERT INTO "dbrdf_height_delta_old2"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_height_delta_new2" t0;
        TRUNCATE TABLE "dbrdf_height_delta_new2";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_notifyDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_notifyDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_notifyDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_notifyDate_delta_old" ON "dbrdf_notifyDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_notifyDate_delta_old" ON "dbrdf_notifyDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_notifyDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_membership_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_membership_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_membership" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_membership_delta_old" ON "dbrdf_membership_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_membership_delta_old" ON "dbrdf_membership_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_membership_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_handedness_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_handedness_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_handedness" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_handedness_delta_old" ON "dbrdf_handedness_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_handedness_delta_old" ON "dbrdf_handedness_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_handedness_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_medlineplus_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_medlineplus_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_medlineplus" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_medlineplus_delta_old" ON "dbrdf_medlineplus_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_medlineplus_delta_old" ON "dbrdf_medlineplus_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_medlineplus_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_buriedPlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_buriedPlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_buriedPlace" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_buriedPlace_delta_old" ON "dbrdf_buriedPlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_buriedPlace_delta_old" ON "dbrdf_buriedPlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_buriedPlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Mammal"(s) SELECT DISTINCT t0.s FROM "dbrdf_Mammal_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Mammal_delta_old";
        INSERT INTO "dbrdf_Mammal_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Mammal_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Mammal_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_cargoWater0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cargoWater_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_cargoWater_delta_old0";
        INSERT INTO "dbrdf_cargoWater_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cargoWater_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_cargoWater_delta_new0";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_role_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_role_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_role" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_role_delta_old" ON "dbrdf_role_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_role_delta_old" ON "dbrdf_role_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_role_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Model"(s) SELECT DISTINCT t0.s FROM "dbrdf_Model_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Model_delta_old";
        INSERT INTO "dbrdf_Model_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Model_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Model_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mostPopulousCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mostPopulousCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_mostPopulousCountry" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mostPopulousCountry_delta_old" ON "dbrdf_mostPopulousCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mostPopulousCountry_delta_old" ON "dbrdf_mostPopulousCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mostPopulousCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_oldcode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_oldcode_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_oldcode" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_oldcode_delta_old" ON "dbrdf_oldcode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_oldcode_delta_old" ON "dbrdf_oldcode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_oldcode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_locationIdentifier_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_locationIdentifier_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_locationIdentifier" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_locationIdentifier_delta_old" ON "dbrdf_locationIdentifier_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_locationIdentifier_delta_old" ON "dbrdf_locationIdentifier_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_locationIdentifier_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_stationStructure_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_stationStructure_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_stationStructure" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_stationStructure_delta_old" ON "dbrdf_stationStructure_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_stationStructure_delta_old" ON "dbrdf_stationStructure_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_stationStructure_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_purpose_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_purpose_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_purpose" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_purpose_delta_old" ON "dbrdf_purpose_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_purpose_delta_old" ON "dbrdf_purpose_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_purpose_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstDriverTeam_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstDriverTeam_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_firstDriverTeam" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstDriverTeam_delta_old" ON "dbrdf_firstDriverTeam_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstDriverTeam_delta_old" ON "dbrdf_firstDriverTeam_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstDriverTeam_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_brainInfoType_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_brainInfoType_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_brainInfoType" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_brainInfoType_delta_old" ON "dbrdf_brainInfoType_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_brainInfoType_delta_old" ON "dbrdf_brainInfoType_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_brainInfoType_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 874
    ---- DEPENDS ON: 873, 815, 743, 133, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Brain>(?X) :- <http://dbpedia.org/ontology/isPartOfAnatomicalStructure>(?X,?X1) .
    INSERT INTO "dbrdf_Brain"(s) SELECT DISTINCT t0.s FROM "dbrdf_isPartOfAnatomicalStructure" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Brain" 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_Brain_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Brain_delta_old"(s) SELECT t0.s FROM "dbrdf_Brain" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Brain_delta_old" ON "dbrdf_Brain_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Brain_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/Brain$delta_new>(?Y) :- <http://dbpedia.org/ontology/Brain$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Brain_delta_new"(s) SELECT t1.o FROM "dbrdf_Brain_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Brain" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Brain"(s) SELECT DISTINCT t0.s FROM "dbrdf_Brain_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Brain_delta_old";
        INSERT INTO "dbrdf_Brain_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Brain_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Brain_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_secretaryGeneral_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_secretaryGeneral_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_secretaryGeneral" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_secretaryGeneral_delta_old" ON "dbrdf_secretaryGeneral_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_secretaryGeneral_delta_old" ON "dbrdf_secretaryGeneral_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_secretaryGeneral_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_animal_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_animal_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_animal" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_animal_delta_old" ON "dbrdf_animal_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_animal_delta_old" ON "dbrdf_animal_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_animal_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_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 879
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_season_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_season_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_season" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_season_delta_old" ON "dbrdf_season_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_season_delta_old" ON "dbrdf_season_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_season_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_VoiceActor"(s) SELECT DISTINCT t0.s FROM "dbrdf_VoiceActor_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_VoiceActor_delta_old";
        INSERT INTO "dbrdf_VoiceActor_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_VoiceActor_delta_new" t0;
        TRUNCATE TABLE "dbrdf_VoiceActor_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_detectionMethod_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_detectionMethod_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_detectionMethod" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_detectionMethod_delta_old" ON "dbrdf_detectionMethod_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_detectionMethod_delta_old" ON "dbrdf_detectionMethod_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_detectionMethod_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtProTournaments_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtProTournaments_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_winsAtProTournaments" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtProTournaments_delta_old" ON "dbrdf_winsAtProTournaments_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtProTournaments_delta_old" ON "dbrdf_winsAtProTournaments_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtProTournaments_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_endDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_endDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_endDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_endDate_delta_old" ON "dbrdf_endDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_endDate_delta_old" ON "dbrdf_endDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_endDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_PokerPlayer"(s) SELECT DISTINCT t0.s FROM "dbrdf_PokerPlayer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_PokerPlayer_delta_old";
        INSERT INTO "dbrdf_PokerPlayer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_PokerPlayer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_PokerPlayer_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_productionEndDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_productionEndDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_productionEndDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_productionEndDate_delta_old" ON "dbrdf_productionEndDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_productionEndDate_delta_old" ON "dbrdf_productionEndDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_productionEndDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_careerPrizeMoney_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_careerPrizeMoney_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_careerPrizeMoney" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_careerPrizeMoney_delta_old" ON "dbrdf_careerPrizeMoney_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_careerPrizeMoney_delta_old" ON "dbrdf_careerPrizeMoney_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_careerPrizeMoney_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_war_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_war_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_war" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_war_delta_old" ON "dbrdf_war_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_war_delta_old" ON "dbrdf_war_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_war_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_complexion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_complexion_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_complexion" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_complexion_delta_old" ON "dbrdf_complexion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_complexion_delta_old" ON "dbrdf_complexion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_complexion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_speaker_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_speaker_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_speaker" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_speaker_delta_old" ON "dbrdf_speaker_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_speaker_delta_old" ON "dbrdf_speaker_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_speaker_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_canonizedDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_canonizedDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_canonizedDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_canonizedDate_delta_old" ON "dbrdf_canonizedDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_canonizedDate_delta_old" ON "dbrdf_canonizedDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_canonizedDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mountainRange_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mountainRange_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_mountainRange" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mountainRange_delta_old" ON "dbrdf_mountainRange_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mountainRange_delta_old" ON "dbrdf_mountainRange_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mountainRange_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_distance0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_distance_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_distance_delta_old0";
        INSERT INTO "dbrdf_distance_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_distance_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_distance_delta_new0";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_position_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_position_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_position" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_position_delta_old" ON "dbrdf_position_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_position_delta_old" ON "dbrdf_position_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_position_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_eyeColor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_eyeColor_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_eyeColor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_eyeColor_delta_old" ON "dbrdf_eyeColor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_eyeColor_delta_old" ON "dbrdf_eyeColor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_eyeColor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_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 896
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_climate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_climate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_climate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_climate_delta_old" ON "dbrdf_climate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_climate_delta_old" ON "dbrdf_climate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_climate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_hometown_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_hometown_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_hometown" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_hometown_delta_old" ON "dbrdf_hometown_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_hometown_delta_old" ON "dbrdf_hometown_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_hometown_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceConfluenceCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sourceConfluenceCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_sourceConfluenceCountry" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sourceConfluenceCountry_delta_old" ON "dbrdf_sourceConfluenceCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sourceConfluenceCountry_delta_old" ON "dbrdf_sourceConfluenceCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceConfluenceCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_CanadianFootballLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_CanadianFootballLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_CanadianFootballLeague_delta_old";
        INSERT INTO "dbrdf_CanadianFootballLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_CanadianFootballLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_CanadianFootballLeague_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lunarRover_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lunarRover_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lunarRover" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lunarRover_delta_old" ON "dbrdf_lunarRover_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lunarRover_delta_old" ON "dbrdf_lunarRover_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lunarRover_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_length_delta_old3"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_length_delta_old3"(s, o) SELECT t0.s, t0.o FROM "dbrdf_length3" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_length_delta_old3" ON "dbrdf_length_delta_old3"(s, o); CREATE INDEX "IDX_1_dbrdf_length_delta_old3" ON "dbrdf_length_delta_old3"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_length_delta_new3"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mgiid_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mgiid_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_mgiid" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mgiid_delta_old" ON "dbrdf_mgiid_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mgiid_delta_old" ON "dbrdf_mgiid_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mgiid_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_borough_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_borough_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_borough" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_borough_delta_old" ON "dbrdf_borough_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_borough_delta_old" ON "dbrdf_borough_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_borough_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lieutenant_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lieutenant_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lieutenant" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lieutenant_delta_old" ON "dbrdf_lieutenant_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lieutenant_delta_old" ON "dbrdf_lieutenant_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lieutenant_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dcc_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dcc_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_dcc" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dcc_delta_old" ON "dbrdf_dcc_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dcc_delta_old" ON "dbrdf_dcc_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dcc_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_torchBearer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_torchBearer_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_torchBearer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_torchBearer_delta_old" ON "dbrdf_torchBearer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_torchBearer_delta_old" ON "dbrdf_torchBearer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_torchBearer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_engineer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_engineer_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_engineer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_engineer_delta_old" ON "dbrdf_engineer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_engineer_delta_old" ON "dbrdf_engineer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_engineer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationDensity_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_populationDensity_delta_old1"(s, o) SELECT t0.s, t0.o FROM "dbrdf_populationDensity1" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_populationDensity_delta_old1" ON "dbrdf_populationDensity_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_populationDensity_delta_old1" ON "dbrdf_populationDensity_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationDensity_delta_new1"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 910
    ---- DEPENDS ON: 909, 728, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [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_populationDensity1" 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/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;

    -- 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 911
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_soccerTournamentThisSeason_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_soccerTournamentThisSeason_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_soccerTournamentThisSeason" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_soccerTournamentThisSeason_delta_old" ON "dbrdf_soccerTournamentThisSeason_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_soccerTournamentThisSeason_delta_old" ON "dbrdf_soccerTournamentThisSeason_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_soccerTournamentThisSeason_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_film_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_film_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_film" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_film_delta_old" ON "dbrdf_film_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_film_delta_old" ON "dbrdf_film_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_film_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Fish"(s) SELECT DISTINCT t0.s FROM "dbrdf_Fish_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Fish_delta_old";
        INSERT INTO "dbrdf_Fish_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Fish_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Fish_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_absoluteMagnitude_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_absoluteMagnitude_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_absoluteMagnitude" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_absoluteMagnitude_delta_old" ON "dbrdf_absoluteMagnitude_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_absoluteMagnitude_delta_old" ON "dbrdf_absoluteMagnitude_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_absoluteMagnitude_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cmpEvaDuration_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cmpEvaDuration_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_cmpEvaDuration" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cmpEvaDuration_delta_old" ON "dbrdf_cmpEvaDuration_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_cmpEvaDuration_delta_old" ON "dbrdf_cmpEvaDuration_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cmpEvaDuration_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_chairmanTitle_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_chairmanTitle_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_chairmanTitle" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_chairmanTitle_delta_old" ON "dbrdf_chairmanTitle_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_chairmanTitle_delta_old" ON "dbrdf_chairmanTitle_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_chairmanTitle_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_squadNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_squadNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_squadNumber" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_squadNumber_delta_old" ON "dbrdf_squadNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_squadNumber_delta_old" ON "dbrdf_squadNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_squadNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_domain_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_domain_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_domain" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_domain_delta_old" ON "dbrdf_domain_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_domain_delta_old" ON "dbrdf_domain_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_domain_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_totalTracks_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_totalTracks_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_totalTracks" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_totalTracks_delta_old" ON "dbrdf_totalTracks_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_totalTracks_delta_old" ON "dbrdf_totalTracks_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_totalTracks_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_richestCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_richestCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_richestCountry" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_richestCountry_delta_old" ON "dbrdf_richestCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_richestCountry_delta_old" ON "dbrdf_richestCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_richestCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_shipDraft_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_shipDraft_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_shipDraft" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_shipDraft_delta_old" ON "dbrdf_shipDraft_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_shipDraft_delta_old" ON "dbrdf_shipDraft_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_shipDraft_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_missionDuration_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_missionDuration_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_missionDuration" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_missionDuration_delta_old" ON "dbrdf_missionDuration_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_missionDuration_delta_old" ON "dbrdf_missionDuration_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_missionDuration_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_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 927
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumBoatBeam_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_maximumBoatBeam_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_maximumBoatBeam" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_maximumBoatBeam_delta_old" ON "dbrdf_maximumBoatBeam_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_maximumBoatBeam_delta_old" ON "dbrdf_maximumBoatBeam_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumBoatBeam_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rgbCoordinateBlue_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rgbCoordinateBlue_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_rgbCoordinateBlue" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rgbCoordinateBlue_delta_old" ON "dbrdf_rgbCoordinateBlue_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rgbCoordinateBlue_delta_old" ON "dbrdf_rgbCoordinateBlue_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rgbCoordinateBlue_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_diameter2"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_diameter_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_diameter_delta_old2";
        INSERT INTO "dbrdf_diameter_delta_old2"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_diameter_delta_new2" t0;
        TRUNCATE TABLE "dbrdf_diameter_delta_new2";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumInclination_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_maximumInclination_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_maximumInclination" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_maximumInclination_delta_old" ON "dbrdf_maximumInclination_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_maximumInclination_delta_old" ON "dbrdf_maximumInclination_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumInclination_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 932
    ---- DEPENDS ON: 931, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Election>(?X) :- <http://dbpedia.org/ontology/popularVote>(?X,?X1) .
    INSERT INTO "dbrdf_Election"(s) SELECT DISTINCT t0.s FROM "dbrdf_popularVote" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Election" 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_Election_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Election_delta_old"(s) SELECT t0.s FROM "dbrdf_Election" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Election_delta_old" ON "dbrdf_Election_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Election_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Election"(s) SELECT DISTINCT t0.s FROM "dbrdf_Election_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Election_delta_old";
        INSERT INTO "dbrdf_Election_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Election_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Election_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lunarOrbitTime_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lunarOrbitTime_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lunarOrbitTime0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lunarOrbitTime_delta_old0" ON "dbrdf_lunarOrbitTime_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_lunarOrbitTime_delta_old0" ON "dbrdf_lunarOrbitTime_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lunarOrbitTime_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_lunarOrbitTime0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lunarOrbitTime_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_lunarOrbitTime_delta_old0";
        INSERT INTO "dbrdf_lunarOrbitTime_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lunarOrbitTime_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_lunarOrbitTime_delta_new0";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_draftRound_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_draftRound_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_draftRound" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_draftRound_delta_old" ON "dbrdf_draftRound_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_draftRound_delta_old" ON "dbrdf_draftRound_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_draftRound_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_meetingRoad_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_meetingRoad_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_meetingRoad" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_meetingRoad_delta_old" ON "dbrdf_meetingRoad_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_meetingRoad_delta_old" ON "dbrdf_meetingRoad_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_meetingRoad_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 936
    ---- DEPENDS ON: 935, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/RoadJunction>(?X) :- <http://dbpedia.org/ontology/meetingRoad>(?X,?X1) .
    INSERT INTO "dbrdf_RoadJunction"(s) SELECT DISTINCT t0.s FROM "dbrdf_meetingRoad" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_RoadJunction" 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_RoadJunction_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_RoadJunction_delta_old"(s) SELECT t0.s FROM "dbrdf_RoadJunction" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_RoadJunction_delta_old" ON "dbrdf_RoadJunction_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_RoadJunction_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/RoadJunction$delta_new>(?Y) :- <http://dbpedia.org/ontology/RoadJunction$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_RoadJunction_delta_new"(s) SELECT t1.o FROM "dbrdf_RoadJunction_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_RoadJunction" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_RoadJunction"(s) SELECT DISTINCT t0.s FROM "dbrdf_RoadJunction_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_RoadJunction_delta_old";
        INSERT INTO "dbrdf_RoadJunction_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_RoadJunction_delta_new" t0;
        TRUNCATE TABLE "dbrdf_RoadJunction_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_retiredRocket_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_retiredRocket_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_retiredRocket" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_retiredRocket_delta_old" ON "dbrdf_retiredRocket_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_retiredRocket_delta_old" ON "dbrdf_retiredRocket_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_retiredRocket_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 938
    ---- DEPENDS ON: 615, 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 939
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_parent_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_parent_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_parent" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_parent_delta_old" ON "dbrdf_parent_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_parent_delta_old" ON "dbrdf_parent_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_parent_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_areaMetro1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_areaMetro_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_areaMetro_delta_old1";
        INSERT INTO "dbrdf_areaMetro_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_areaMetro_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_areaMetro_delta_new1";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mayor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mayor_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_mayor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mayor_delta_old" ON "dbrdf_mayor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mayor_delta_old" ON "dbrdf_mayor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mayor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfSuites_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfSuites_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfSuites" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfSuites_delta_old" ON "dbrdf_numberOfSuites_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfSuites_delta_old" ON "dbrdf_numberOfSuites_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfSuites_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_review_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_review_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_review" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_review_delta_old" ON "dbrdf_review_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_review_delta_old" ON "dbrdf_review_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_review_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_almaMater_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_almaMater_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_almaMater" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_almaMater_delta_old" ON "dbrdf_almaMater_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_almaMater_delta_old" ON "dbrdf_almaMater_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_almaMater_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_PolishKing"(s) SELECT DISTINCT t0.s FROM "dbrdf_PolishKing_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_PolishKing_delta_old";
        INSERT INTO "dbrdf_PolishKing_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_PolishKing_delta_new" t0;
        TRUNCATE TABLE "dbrdf_PolishKing_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_electionDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_electionDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_electionDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_electionDate_delta_old" ON "dbrdf_electionDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_electionDate_delta_old" ON "dbrdf_electionDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_electionDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dissolutionYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dissolutionYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_dissolutionYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dissolutionYear_delta_old" ON "dbrdf_dissolutionYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dissolutionYear_delta_old" ON "dbrdf_dissolutionYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dissolutionYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_iucnCategory_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_iucnCategory_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_iucnCategory" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_iucnCategory_delta_old" ON "dbrdf_iucnCategory_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_iucnCategory_delta_old" ON "dbrdf_iucnCategory_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_iucnCategory_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 949
    ---- DEPENDS ON: 948, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/ProtectedArea>(?X) :- <http://dbpedia.org/ontology/iucnCategory>(?X,?X1) .
    INSERT INTO "dbrdf_ProtectedArea"(s) SELECT DISTINCT t0.s FROM "dbrdf_iucnCategory" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_ProtectedArea" 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_ProtectedArea_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ProtectedArea_delta_old"(s) SELECT t0.s FROM "dbrdf_ProtectedArea" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ProtectedArea_delta_old" ON "dbrdf_ProtectedArea_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ProtectedArea_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_ProtectedArea"(s) SELECT DISTINCT t0.s FROM "dbrdf_ProtectedArea_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_ProtectedArea_delta_old";
        INSERT INTO "dbrdf_ProtectedArea_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_ProtectedArea_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ProtectedArea_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_orbitalFlights_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_orbitalFlights_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_orbitalFlights" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_orbitalFlights_delta_old" ON "dbrdf_orbitalFlights_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_orbitalFlights_delta_old" ON "dbrdf_orbitalFlights_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_orbitalFlights_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_production_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_production_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_production" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_production_delta_old" ON "dbrdf_production_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_production_delta_old" ON "dbrdf_production_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_production_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastLaunchDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lastLaunchDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lastLaunchDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lastLaunchDate_delta_old" ON "dbrdf_lastLaunchDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lastLaunchDate_delta_old" ON "dbrdf_lastLaunchDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastLaunchDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_BritishRoyalty"(s) SELECT DISTINCT t0.s FROM "dbrdf_BritishRoyalty_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_BritishRoyalty_delta_old";
        INSERT INTO "dbrdf_BritishRoyalty_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_BritishRoyalty_delta_new" t0;
        TRUNCATE TABLE "dbrdf_BritishRoyalty_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_creativeDirector_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_creativeDirector_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_creativeDirector" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_creativeDirector_delta_old" ON "dbrdf_creativeDirector_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_creativeDirector_delta_old" ON "dbrdf_creativeDirector_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_creativeDirector_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_gun_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_gun_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_gun" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_gun_delta_old" ON "dbrdf_gun_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_gun_delta_old" ON "dbrdf_gun_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_gun_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mostPopulatedCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mostPopulatedCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_mostPopulatedCountry" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mostPopulatedCountry_delta_old" ON "dbrdf_mostPopulatedCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mostPopulatedCountry_delta_old" ON "dbrdf_mostPopulatedCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mostPopulatedCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_regionalLanguage_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_regionalLanguage_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_regionalLanguage" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_regionalLanguage_delta_old" ON "dbrdf_regionalLanguage_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_regionalLanguage_delta_old" ON "dbrdf_regionalLanguage_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_regionalLanguage_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mainOrgan_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mainOrgan_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_mainOrgan" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mainOrgan_delta_old" ON "dbrdf_mainOrgan_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mainOrgan_delta_old" ON "dbrdf_mainOrgan_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mainOrgan_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_largestCity_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_largestCity_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_largestCity" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_largestCity_delta_old" ON "dbrdf_largestCity_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_largestCity_delta_old" ON "dbrdf_largestCity_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_largestCity_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_programmeFormat_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_programmeFormat_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_programmeFormat" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_programmeFormat_delta_old" ON "dbrdf_programmeFormat_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_programmeFormat_delta_old" ON "dbrdf_programmeFormat_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_programmeFormat_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_SambaSchool"(s) SELECT DISTINCT t0.s FROM "dbrdf_SambaSchool_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SambaSchool_delta_old";
        INSERT INTO "dbrdf_SambaSchool_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SambaSchool_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SambaSchool_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_denomination_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_denomination_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_denomination" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_denomination_delta_old" ON "dbrdf_denomination_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_denomination_delta_old" ON "dbrdf_denomination_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_denomination_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ecNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ecNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_ecNumber" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ecNumber_delta_old" ON "dbrdf_ecNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ecNumber_delta_old" ON "dbrdf_ecNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ecNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ideology_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ideology_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_ideology" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ideology_delta_old" ON "dbrdf_ideology_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ideology_delta_old" ON "dbrdf_ideology_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ideology_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 965
    ---- DEPENDS ON: 964, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Ideology>(?X1) :- <http://dbpedia.org/ontology/ideology>(?X,?X1) .
    INSERT INTO "dbrdf_Ideology"(s) SELECT DISTINCT t0.o FROM "dbrdf_ideology" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Ideology" 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_Ideology_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Ideology_delta_old"(s) SELECT t0.s FROM "dbrdf_Ideology" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Ideology_delta_old" ON "dbrdf_Ideology_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Ideology_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/Ideology$delta_new>(?Y) :- <http://dbpedia.org/ontology/Ideology$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Ideology_delta_new"(s) SELECT t1.o FROM "dbrdf_Ideology_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Ideology" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Ideology"(s) SELECT DISTINCT t0.s FROM "dbrdf_Ideology_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Ideology_delta_old";
        INSERT INTO "dbrdf_Ideology_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Ideology_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Ideology_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_hasSurfaceForm_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_hasSurfaceForm_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_hasSurfaceForm" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_hasSurfaceForm_delta_old" ON "dbrdf_hasSurfaceForm_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_hasSurfaceForm_delta_old" ON "dbrdf_hasSurfaceForm_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_hasSurfaceForm_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_splitFromParty_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_splitFromParty_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_splitFromParty" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_splitFromParty_delta_old" ON "dbrdf_splitFromParty_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_splitFromParty_delta_old" ON "dbrdf_splitFromParty_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_splitFromParty_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dorlandsSuffix_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dorlandsSuffix_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_dorlandsSuffix" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dorlandsSuffix_delta_old" ON "dbrdf_dorlandsSuffix_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dorlandsSuffix_delta_old" ON "dbrdf_dorlandsSuffix_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dorlandsSuffix_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_demolitionDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_demolitionDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_demolitionDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_demolitionDate_delta_old" ON "dbrdf_demolitionDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_demolitionDate_delta_old" ON "dbrdf_demolitionDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_demolitionDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_specialEffects_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_specialEffects_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_specialEffects" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_specialEffects_delta_old" ON "dbrdf_specialEffects_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_specialEffects_delta_old" ON "dbrdf_specialEffects_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_specialEffects_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_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 973
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_movement_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_movement_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_movement" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_movement_delta_old" ON "dbrdf_movement_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_movement_delta_old" ON "dbrdf_movement_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_movement_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dateClosed_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dateClosed_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_dateClosed" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dateClosed_delta_old" ON "dbrdf_dateClosed_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dateClosed_delta_old" ON "dbrdf_dateClosed_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dateClosed_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_field_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_field_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_field" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_field_delta_old" ON "dbrdf_field_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_field_delta_old" ON "dbrdf_field_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_field_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_afiAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_afiAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_afiAward" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_afiAward_delta_old" ON "dbrdf_afiAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_afiAward_delta_old" ON "dbrdf_afiAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_afiAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 977
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_isPeerReviewed_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_isPeerReviewed_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_isPeerReviewed" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_isPeerReviewed_delta_old" ON "dbrdf_isPeerReviewed_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_isPeerReviewed_delta_old" ON "dbrdf_isPeerReviewed_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_isPeerReviewed_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 978
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_chromosome_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_chromosome_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_chromosome" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_chromosome_delta_old" ON "dbrdf_chromosome_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_chromosome_delta_old" ON "dbrdf_chromosome_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_chromosome_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 979
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_associatedBand_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_associatedBand_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_associatedBand" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_associatedBand_delta_old" ON "dbrdf_associatedBand_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_associatedBand_delta_old" ON "dbrdf_associatedBand_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_associatedBand_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 980
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_prospectTeam_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_prospectTeam_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_prospectTeam" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_prospectTeam_delta_old" ON "dbrdf_prospectTeam_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_prospectTeam_delta_old" ON "dbrdf_prospectTeam_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_prospectTeam_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 981
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_arielAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_arielAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_arielAward" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_arielAward_delta_old" ON "dbrdf_arielAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_arielAward_delta_old" ON "dbrdf_arielAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_arielAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 982
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_educationSystem_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_educationSystem_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_educationSystem" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_educationSystem_delta_old" ON "dbrdf_educationSystem_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_educationSystem_delta_old" ON "dbrdf_educationSystem_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_educationSystem_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 983
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastWin_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lastWin_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lastWin" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lastWin_delta_old" ON "dbrdf_lastWin_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lastWin_delta_old" ON "dbrdf_lastWin_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastWin_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 984
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtChampionships_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtChampionships_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_winsAtChampionships" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtChampionships_delta_old" ON "dbrdf_winsAtChampionships_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtChampionships_delta_old" ON "dbrdf_winsAtChampionships_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtChampionships_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 985
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_currentSeason_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_currentSeason_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_currentSeason" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_currentSeason_delta_old" ON "dbrdf_currentSeason_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_currentSeason_delta_old" ON "dbrdf_currentSeason_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_currentSeason_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 986
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_modelEndDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_modelEndDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_modelEndDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_modelEndDate_delta_old" ON "dbrdf_modelEndDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_modelEndDate_delta_old" ON "dbrdf_modelEndDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_modelEndDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 987
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_generalManager_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_generalManager_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_generalManager" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_generalManager_delta_old" ON "dbrdf_generalManager_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_generalManager_delta_old" ON "dbrdf_generalManager_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_generalManager_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 988
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfStudioAlbums_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfStudioAlbums_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfStudioAlbums" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfStudioAlbums_delta_old" ON "dbrdf_numberOfStudioAlbums_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfStudioAlbums_delta_old" ON "dbrdf_numberOfStudioAlbums_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfStudioAlbums_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 989
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_formationYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_formationYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_formationYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_formationYear_delta_old" ON "dbrdf_formationYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_formationYear_delta_old" ON "dbrdf_formationYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_formationYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 990
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_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 991
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_unloCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_unloCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_unloCode" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_unloCode_delta_old" ON "dbrdf_unloCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_unloCode_delta_old" ON "dbrdf_unloCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_unloCode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 992
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 993
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_maidenFlightRocket_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_maidenFlightRocket_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_maidenFlightRocket" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_maidenFlightRocket_delta_old" ON "dbrdf_maidenFlightRocket_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_maidenFlightRocket_delta_old" ON "dbrdf_maidenFlightRocket_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_maidenFlightRocket_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_characterInPlay_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_characterInPlay_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_characterInPlay" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_characterInPlay_delta_old" ON "dbrdf_characterInPlay_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_characterInPlay_delta_old" ON "dbrdf_characterInPlay_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_characterInPlay_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_launchSite_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_launchSite_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_launchSite" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_launchSite_delta_old" ON "dbrdf_launchSite_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_launchSite_delta_old" ON "dbrdf_launchSite_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_launchSite_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_refseqmrna_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_refseqmrna_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_refseqmrna" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_refseqmrna_delta_old" ON "dbrdf_refseqmrna_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_refseqmrna_delta_old" ON "dbrdf_refseqmrna_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_refseqmrna_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_wingspan_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_wingspan_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_wingspan" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_wingspan_delta_old" ON "dbrdf_wingspan_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_wingspan_delta_old" ON "dbrdf_wingspan_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_wingspan_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_mass2"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_mass_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_mass_delta_old2";
        INSERT INTO "dbrdf_mass_delta_old2"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_mass_delta_new2" t0;
        TRUNCATE TABLE "dbrdf_mass_delta_new2";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 999
    ---- DEPENDS ON: 603, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Theatre>(?X) :- <http://dbpedia.org/ontology/currentProduction>(?X,?X1) .
    INSERT INTO "dbrdf_Theatre"(s) SELECT DISTINCT t0.s FROM "dbrdf_currentProduction" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Theatre" 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_Theatre_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Theatre_delta_old"(s) SELECT t0.s FROM "dbrdf_Theatre" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Theatre_delta_old" ON "dbrdf_Theatre_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Theatre_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/Theatre$delta_new>(?Y) :- <http://dbpedia.org/ontology/Theatre$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Theatre_delta_new"(s) SELECT t1.o FROM "dbrdf_Theatre_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Theatre" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Theatre"(s) SELECT DISTINCT t0.s FROM "dbrdf_Theatre_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Theatre_delta_old";
        INSERT INTO "dbrdf_Theatre_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Theatre_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Theatre_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1000
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

