        INSERT INTO "dbrdf_accessDate_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_accessDate_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_accessDate" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1338
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1339
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1340
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1341
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_RugbyPlayer"(s) SELECT DISTINCT t0.s FROM "dbrdf_RugbyPlayer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_RugbyPlayer_delta_old";
        INSERT INTO "dbrdf_RugbyPlayer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_RugbyPlayer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_RugbyPlayer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1342
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lyrics_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lyrics_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lyrics" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lyrics_delta_old" ON "dbrdf_lyrics_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lyrics_delta_old" ON "dbrdf_lyrics_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lyrics_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1343
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1344
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1345
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1346
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastElectionDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lastElectionDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lastElectionDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lastElectionDate_delta_old" ON "dbrdf_lastElectionDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lastElectionDate_delta_old" ON "dbrdf_lastElectionDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastElectionDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1347
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_distributingLabel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_distributingLabel_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_distributingLabel" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_distributingLabel_delta_old" ON "dbrdf_distributingLabel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_distributingLabel_delta_old" ON "dbrdf_distributingLabel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_distributingLabel_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1348
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1349
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1350
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1351
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1352
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1353
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nationalYears_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nationalYears_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_nationalYears" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nationalYears_delta_old" ON "dbrdf_nationalYears_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nationalYears_delta_old" ON "dbrdf_nationalYears_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nationalYears_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1354
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_structuralSystem_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_structuralSystem_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_structuralSystem" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_structuralSystem_delta_old" ON "dbrdf_structuralSystem_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_structuralSystem_delta_old" ON "dbrdf_structuralSystem_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_structuralSystem_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1355
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_shareSource_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_shareSource_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_shareSource" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_shareSource_delta_old" ON "dbrdf_shareSource_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_shareSource_delta_old" ON "dbrdf_shareSource_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_shareSource_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1356
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_distance1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_distance_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_distance_delta_old1";
        INSERT INTO "dbrdf_distance_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_distance_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_distance_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1357
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_binomial_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_binomial_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_binomial" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_binomial_delta_old" ON "dbrdf_binomial_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_binomial_delta_old" ON "dbrdf_binomial_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_binomial_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1358
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_elevation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_elevation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_elevation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_elevation_delta_old" ON "dbrdf_elevation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_elevation_delta_old" ON "dbrdf_elevation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_elevation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1359
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_summerAppearances_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_summerAppearances_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_summerAppearances" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_summerAppearances_delta_old" ON "dbrdf_summerAppearances_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_summerAppearances_delta_old" ON "dbrdf_summerAppearances_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_summerAppearances_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1360
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Ambassador"(s) SELECT DISTINCT t0.s FROM "dbrdf_Ambassador_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Ambassador_delta_old";
        INSERT INTO "dbrdf_Ambassador_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Ambassador_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Ambassador_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1361
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsMainPart_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_alpsMainPart_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_alpsMainPart" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_alpsMainPart_delta_old" ON "dbrdf_alpsMainPart_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_alpsMainPart_delta_old" ON "dbrdf_alpsMainPart_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsMainPart_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1362
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_latestReleaseDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_latestReleaseDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_latestReleaseDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_latestReleaseDate_delta_old" ON "dbrdf_latestReleaseDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_latestReleaseDate_delta_old" ON "dbrdf_latestReleaseDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_latestReleaseDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1363
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lowest_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lowest_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lowest" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lowest_delta_old" ON "dbrdf_lowest_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lowest_delta_old" ON "dbrdf_lowest_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lowest_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1364
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_waterwayThroughTunnel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_waterwayThroughTunnel_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_waterwayThroughTunnel" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_waterwayThroughTunnel_delta_old" ON "dbrdf_waterwayThroughTunnel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_waterwayThroughTunnel_delta_old" ON "dbrdf_waterwayThroughTunnel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_waterwayThroughTunnel_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1365
    ---- DEPENDS ON: 1364, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/WaterwayTunnel>(?X) :- <http://dbpedia.org/ontology/waterwayThroughTunnel>(?X,?X1) .
    INSERT INTO "dbrdf_WaterwayTunnel"(s) SELECT DISTINCT t0.s FROM "dbrdf_waterwayThroughTunnel" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_WaterwayTunnel" 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_WaterwayTunnel_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_WaterwayTunnel_delta_old"(s) SELECT t0.s FROM "dbrdf_WaterwayTunnel" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_WaterwayTunnel_delta_old" ON "dbrdf_WaterwayTunnel_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_WaterwayTunnel_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/WaterwayTunnel$delta_new>(?Y) :- <http://dbpedia.org/ontology/WaterwayTunnel$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_WaterwayTunnel_delta_new"(s) SELECT t1.o FROM "dbrdf_WaterwayTunnel_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_WaterwayTunnel" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_WaterwayTunnel"(s) SELECT DISTINCT t0.s FROM "dbrdf_WaterwayTunnel_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_WaterwayTunnel_delta_old";
        INSERT INTO "dbrdf_WaterwayTunnel_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_WaterwayTunnel_delta_new" t0;
        TRUNCATE TABLE "dbrdf_WaterwayTunnel_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1366
    ---- DEPENDS ON: 1365, 429, 610, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

    -- [Rule] <http://dbpedia.org/ontology/Tunnel>(?X) :- <http://dbpedia.org/ontology/RailwayTunnel>(?X) .
    INSERT INTO "dbrdf_Tunnel"(s) SELECT t0.s FROM "dbrdf_RailwayTunnel" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Tunnel" 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_Tunnel_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Tunnel_delta_old"(s) SELECT t0.s FROM "dbrdf_Tunnel" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Tunnel_delta_old" ON "dbrdf_Tunnel_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Tunnel_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/Tunnel$delta_new>(?Y) :- <http://dbpedia.org/ontology/Tunnel$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Tunnel_delta_new"(s) SELECT t1.o FROM "dbrdf_Tunnel_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Tunnel" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Tunnel"(s) SELECT DISTINCT t0.s FROM "dbrdf_Tunnel_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Tunnel_delta_old";
        INSERT INTO "dbrdf_Tunnel_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Tunnel_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Tunnel_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1367
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_flyingHours_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_flyingHours_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_flyingHours" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_flyingHours_delta_old" ON "dbrdf_flyingHours_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_flyingHours_delta_old" ON "dbrdf_flyingHours_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_flyingHours_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1368
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_shoots_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_shoots_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_shoots" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_shoots_delta_old" ON "dbrdf_shoots_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_shoots_delta_old" ON "dbrdf_shoots_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_shoots_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1369
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstAppearance_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstAppearance_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_firstAppearance" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstAppearance_delta_old" ON "dbrdf_firstAppearance_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstAppearance_delta_old" ON "dbrdf_firstAppearance_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstAppearance_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1370
    ---- DEPENDS ON: 1369, 305, 131, 41, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/FictionalCharacter>(?X) :- <http://dbpedia.org/ontology/lastAppearance>(?X,?X1) .
    INSERT INTO "dbrdf_FictionalCharacter"(s) SELECT DISTINCT t0.s FROM "dbrdf_lastAppearance" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_FictionalCharacter" 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_FictionalCharacter_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_FictionalCharacter_delta_old"(s) SELECT t0.s FROM "dbrdf_FictionalCharacter" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_FictionalCharacter_delta_old" ON "dbrdf_FictionalCharacter_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_FictionalCharacter_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/FictionalCharacter$delta_new>(?Y) :- <http://dbpedia.org/ontology/FictionalCharacter$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_FictionalCharacter_delta_new"(s) SELECT t1.o FROM "dbrdf_FictionalCharacter_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_FictionalCharacter" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_FictionalCharacter"(s) SELECT DISTINCT t0.s FROM "dbrdf_FictionalCharacter_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_FictionalCharacter_delta_old";
        INSERT INTO "dbrdf_FictionalCharacter_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_FictionalCharacter_delta_new" t0;
        TRUNCATE TABLE "dbrdf_FictionalCharacter_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1371
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nationalTopographicSystemMapNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nationalTopographicSystemMapNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_nationalTopographicSystemMapNumber" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nationalTopographicSystemMapNumber_delta_old" ON "dbrdf_nationalTopographicSystemMapNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nationalTopographicSystemMapNumber_delta_old" ON "dbrdf_nationalTopographicSystemMapNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nationalTopographicSystemMapNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1372
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_weight2"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_weight_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_weight_delta_old2";
        INSERT INTO "dbrdf_weight_delta_old2"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_weight_delta_new2" t0;
        TRUNCATE TABLE "dbrdf_weight_delta_new2";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1373
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_originalMaximumBoatLength0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_originalMaximumBoatLength_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_originalMaximumBoatLength_delta_old0";
        INSERT INTO "dbrdf_originalMaximumBoatLength_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_originalMaximumBoatLength_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_originalMaximumBoatLength_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1374
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_titleDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_titleDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_titleDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_titleDate_delta_old" ON "dbrdf_titleDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_titleDate_delta_old" ON "dbrdf_titleDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_titleDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1375
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mergedIntoParty_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mergedIntoParty_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_mergedIntoParty" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mergedIntoParty_delta_old" ON "dbrdf_mergedIntoParty_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mergedIntoParty_delta_old" ON "dbrdf_mergedIntoParty_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mergedIntoParty_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1376
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_governmentPosition_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_governmentPosition_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_governmentPosition" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_governmentPosition_delta_old" ON "dbrdf_governmentPosition_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_governmentPosition_delta_old" ON "dbrdf_governmentPosition_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_governmentPosition_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1377
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1378
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_ChemicalElement"(s) SELECT DISTINCT t0.s FROM "dbrdf_ChemicalElement_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_ChemicalElement_delta_old";
        INSERT INTO "dbrdf_ChemicalElement_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_ChemicalElement_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ChemicalElement_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1379
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1380
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dateOfBurial_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dateOfBurial_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_dateOfBurial" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dateOfBurial_delta_old" ON "dbrdf_dateOfBurial_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dateOfBurial_delta_old" ON "dbrdf_dateOfBurial_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dateOfBurial_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1381
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_tonyAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_tonyAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_tonyAward" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_tonyAward_delta_old" ON "dbrdf_tonyAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_tonyAward_delta_old" ON "dbrdf_tonyAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_tonyAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1382
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfStaff_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfStaff_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfStaff" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfStaff_delta_old" ON "dbrdf_numberOfStaff_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfStaff_delta_old" ON "dbrdf_numberOfStaff_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfStaff_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1383
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfRockets_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfRockets_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfRockets" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfRockets_delta_old" ON "dbrdf_numberOfRockets_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfRockets_delta_old" ON "dbrdf_numberOfRockets_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfRockets_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1384
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1385
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rebuildingYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rebuildingYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_rebuildingYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rebuildingYear_delta_old" ON "dbrdf_rebuildingYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rebuildingYear_delta_old" ON "dbrdf_rebuildingYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rebuildingYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1386
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_channel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_channel_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_channel" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_channel_delta_old" ON "dbrdf_channel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_channel_delta_old" ON "dbrdf_channel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_channel_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1387
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lowestRegion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lowestRegion_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lowestRegion" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lowestRegion_delta_old" ON "dbrdf_lowestRegion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lowestRegion_delta_old" ON "dbrdf_lowestRegion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lowestRegion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1388
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_managementPlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_managementPlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_managementPlace" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_managementPlace_delta_old" ON "dbrdf_managementPlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_managementPlace_delta_old" ON "dbrdf_managementPlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_managementPlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1389
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_voltageOfElectrification_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_voltageOfElectrification_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_voltageOfElectrification" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_voltageOfElectrification_delta_old" ON "dbrdf_voltageOfElectrification_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_voltageOfElectrification_delta_old" ON "dbrdf_voltageOfElectrification_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_voltageOfElectrification_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1390
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1391
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_draftPick_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_draftPick_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_draftPick" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_draftPick_delta_old" ON "dbrdf_draftPick_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_draftPick_delta_old" ON "dbrdf_draftPick_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_draftPick_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1392
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_period_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_period_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_period" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_period_delta_old" ON "dbrdf_period_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_period_delta_old" ON "dbrdf_period_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_period_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1393
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_officialLanguage_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_officialLanguage_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_officialLanguage" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_officialLanguage_delta_old" ON "dbrdf_officialLanguage_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_officialLanguage_delta_old" ON "dbrdf_officialLanguage_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_officialLanguage_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1394
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_keyPerson_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_keyPerson_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_keyPerson" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_keyPerson_delta_old" ON "dbrdf_keyPerson_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_keyPerson_delta_old" ON "dbrdf_keyPerson_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_keyPerson_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1395
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_person_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_person_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_person" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_person_delta_old" ON "dbrdf_person_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_person_delta_old" ON "dbrdf_person_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_person_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1396
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_executiveProducer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_executiveProducer_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_executiveProducer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_executiveProducer_delta_old" ON "dbrdf_executiveProducer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_executiveProducer_delta_old" ON "dbrdf_executiveProducer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_executiveProducer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1397
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cargoGas_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cargoGas_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_cargoGas" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cargoGas_delta_old" ON "dbrdf_cargoGas_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_cargoGas_delta_old" ON "dbrdf_cargoGas_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cargoGas_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1398
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_unitaryAuthority_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_unitaryAuthority_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_unitaryAuthority" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_unitaryAuthority_delta_old" ON "dbrdf_unitaryAuthority_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_unitaryAuthority_delta_old" ON "dbrdf_unitaryAuthority_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_unitaryAuthority_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1399
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_albedo_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_albedo_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_albedo" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_albedo_delta_old" ON "dbrdf_albedo_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_albedo_delta_old" ON "dbrdf_albedo_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_albedo_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1400
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_identificationSymbol_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_identificationSymbol_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_identificationSymbol" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_identificationSymbol_delta_old" ON "dbrdf_identificationSymbol_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_identificationSymbol_delta_old" ON "dbrdf_identificationSymbol_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_identificationSymbol_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1401
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1402
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_designCompany_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_designCompany_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_designCompany" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_designCompany_delta_old" ON "dbrdf_designCompany_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_designCompany_delta_old" ON "dbrdf_designCompany_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_designCompany_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1403
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_whaDraftTeam_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_whaDraftTeam_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_whaDraftTeam" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_whaDraftTeam_delta_old" ON "dbrdf_whaDraftTeam_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_whaDraftTeam_delta_old" ON "dbrdf_whaDraftTeam_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_whaDraftTeam_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1404
    ---- DEPENDS ON: 1403, 980, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- [Rule] <http://dbpedia.org/ontology/HockeyTeam>(?X1) :- <http://dbpedia.org/ontology/prospectTeam>(?X,?X1) .
    INSERT INTO "dbrdf_HockeyTeam"(s) SELECT DISTINCT t0.o FROM "dbrdf_prospectTeam" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_HockeyTeam" 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_HockeyTeam_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_HockeyTeam_delta_old"(s) SELECT t0.s FROM "dbrdf_HockeyTeam" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_HockeyTeam_delta_old" ON "dbrdf_HockeyTeam_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_HockeyTeam_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/HockeyTeam$delta_new>(?Y) :- <http://dbpedia.org/ontology/HockeyTeam$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_HockeyTeam_delta_new"(s) SELECT t1.o FROM "dbrdf_HockeyTeam_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_HockeyTeam" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_HockeyTeam"(s) SELECT DISTINCT t0.s FROM "dbrdf_HockeyTeam_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_HockeyTeam_delta_old";
        INSERT INTO "dbrdf_HockeyTeam_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_HockeyTeam_delta_new" t0;
        TRUNCATE TABLE "dbrdf_HockeyTeam_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1405
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_precursor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_precursor_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_precursor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_precursor_delta_old" ON "dbrdf_precursor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_precursor_delta_old" ON "dbrdf_precursor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_precursor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1406
    ---- DEPENDS ON: 1405, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Embryology>(?X1) :- <http://dbpedia.org/ontology/precursor>(?X,?X1) .
    INSERT INTO "dbrdf_Embryology"(s) SELECT DISTINCT t0.o FROM "dbrdf_precursor" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Embryology" 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_Embryology_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Embryology_delta_old"(s) SELECT t0.s FROM "dbrdf_Embryology" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Embryology_delta_old" ON "dbrdf_Embryology_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Embryology_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/Embryology$delta_new>(?Y) :- <http://dbpedia.org/ontology/Embryology$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Embryology_delta_new"(s) SELECT t1.o FROM "dbrdf_Embryology_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Embryology" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Embryology"(s) SELECT DISTINCT t0.s FROM "dbrdf_Embryology_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Embryology_delta_old";
        INSERT INTO "dbrdf_Embryology_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Embryology_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Embryology_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1407
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_manxName_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_manxName_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_manxName" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_manxName_delta_old" ON "dbrdf_manxName_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_manxName_delta_old" ON "dbrdf_manxName_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_manxName_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1408
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_daylightSavingTimeZone_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_daylightSavingTimeZone_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_daylightSavingTimeZone" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_daylightSavingTimeZone_delta_old" ON "dbrdf_daylightSavingTimeZone_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_daylightSavingTimeZone_delta_old" ON "dbrdf_daylightSavingTimeZone_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_daylightSavingTimeZone_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1409
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dubber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dubber_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_dubber" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dubber_delta_old" ON "dbrdf_dubber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dubber_delta_old" ON "dbrdf_dubber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dubber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1410
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lowerAge_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lowerAge_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lowerAge" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lowerAge_delta_old" ON "dbrdf_lowerAge_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lowerAge_delta_old" ON "dbrdf_lowerAge_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lowerAge_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1411
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_launchPad_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_launchPad_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_launchPad" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_launchPad_delta_old" ON "dbrdf_launchPad_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_launchPad_delta_old" ON "dbrdf_launchPad_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_launchPad_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1412
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_director_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_director_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_director" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_director_delta_old" ON "dbrdf_director_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_director_delta_old" ON "dbrdf_director_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_director_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1413
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumElevation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_maximumElevation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_maximumElevation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_maximumElevation_delta_old" ON "dbrdf_maximumElevation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_maximumElevation_delta_old" ON "dbrdf_maximumElevation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumElevation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1414
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_associateEditor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_associateEditor_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_associateEditor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_associateEditor_delta_old" ON "dbrdf_associateEditor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_associateEditor_delta_old" ON "dbrdf_associateEditor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_associateEditor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1415
    ---- DEPENDS ON: 1414, 1203, 717, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Newspaper>(?X1) :- <http://dbpedia.org/ontology/sisterNewspaper>(?X,?X1) .
    INSERT INTO "dbrdf_Newspaper"(s) SELECT DISTINCT t0.o FROM "dbrdf_sisterNewspaper" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Newspaper" 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_Newspaper_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Newspaper_delta_old"(s) SELECT t0.s FROM "dbrdf_Newspaper" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Newspaper_delta_old" ON "dbrdf_Newspaper_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Newspaper_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/Newspaper$delta_new>(?Y) :- <http://dbpedia.org/ontology/Newspaper$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Newspaper_delta_new"(s) SELECT t1.o FROM "dbrdf_Newspaper_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Newspaper" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Newspaper"(s) SELECT DISTINCT t0.s FROM "dbrdf_Newspaper_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Newspaper_delta_old";
        INSERT INTO "dbrdf_Newspaper_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Newspaper_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Newspaper_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1416
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_currentRank_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_currentRank_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_currentRank" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_currentRank_delta_old" ON "dbrdf_currentRank_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_currentRank_delta_old" ON "dbrdf_currentRank_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_currentRank_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1417
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_LacrosseLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_LacrosseLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_LacrosseLeague_delta_old";
        INSERT INTO "dbrdf_LacrosseLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_LacrosseLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_LacrosseLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1418
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_painter_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_painter_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_painter" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_painter_delta_old" ON "dbrdf_painter_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_painter_delta_old" ON "dbrdf_painter_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_painter_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1419
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_countryOrigin_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_countryOrigin_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_countryOrigin" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_countryOrigin_delta_old" ON "dbrdf_countryOrigin_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_countryOrigin_delta_old" ON "dbrdf_countryOrigin_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_countryOrigin_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1420
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_BaseballLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_BaseballLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_BaseballLeague_delta_old";
        INSERT INTO "dbrdf_BaseballLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_BaseballLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_BaseballLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1421
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_significantProject_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_significantProject_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_significantProject" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_significantProject_delta_old" ON "dbrdf_significantProject_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_significantProject_delta_old" ON "dbrdf_significantProject_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_significantProject_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1422
    ---- DEPENDS ON: 1421, 335, 48, 11, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Architect>(?X) :- <http://dbpedia.org/ontology/significantDesign>(?X,?X1) .
    INSERT INTO "dbrdf_Architect"(s) SELECT DISTINCT t0.s FROM "dbrdf_significantDesign" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Architect" 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_Architect_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Architect_delta_old"(s) SELECT t0.s FROM "dbrdf_Architect" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Architect_delta_old" ON "dbrdf_Architect_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Architect_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/Architect$delta_new>(?Y) :- <http://dbpedia.org/ontology/Architect$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Architect_delta_new"(s) SELECT t1.o FROM "dbrdf_Architect_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Architect" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Architect"(s) SELECT DISTINCT t0.s FROM "dbrdf_Architect_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Architect_delta_old";
        INSERT INTO "dbrdf_Architect_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Architect_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Architect_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1423
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsSupergroup_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_alpsSupergroup_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_alpsSupergroup" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_alpsSupergroup_delta_old" ON "dbrdf_alpsSupergroup_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_alpsSupergroup_delta_old" ON "dbrdf_alpsSupergroup_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsSupergroup_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1424
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstDriverCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstDriverCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_firstDriverCountry" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstDriverCountry_delta_old" ON "dbrdf_firstDriverCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstDriverCountry_delta_old" ON "dbrdf_firstDriverCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstDriverCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1425
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Mineral"(s) SELECT DISTINCT t0.s FROM "dbrdf_Mineral_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Mineral_delta_old";
        INSERT INTO "dbrdf_Mineral_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Mineral_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Mineral_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1426
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lifeExpectancy_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lifeExpectancy_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lifeExpectancy" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lifeExpectancy_delta_old" ON "dbrdf_lifeExpectancy_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lifeExpectancy_delta_old" ON "dbrdf_lifeExpectancy_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lifeExpectancy_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1427
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_material_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_material_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_material" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_material_delta_old" ON "dbrdf_material_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_material_delta_old" ON "dbrdf_material_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_material_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1428
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_functionStartYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_functionStartYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_functionStartYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_functionStartYear_delta_old" ON "dbrdf_functionStartYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_functionStartYear_delta_old" ON "dbrdf_functionStartYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_functionStartYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1429
    ---- DEPENDS ON: 1271, 1063, 942, 854, 672, 558, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Hotel_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Hotel_delta_old"(s) SELECT t0.s FROM "dbrdf_Hotel" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Hotel_delta_old" ON "dbrdf_Hotel_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Hotel_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Hotel_delta_old0"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Hotel_delta_old0"(s) SELECT t0.s FROM "dbrdf_Hotel0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Hotel_delta_old0" ON "dbrdf_Hotel_delta_old0"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Hotel_delta_new0"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


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


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


        -- Propagate $delta_new

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

        INSERT INTO "dbrdf_Hotel0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Hotel_delta_new0" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Hotel_delta_old0";
        INSERT INTO "dbrdf_Hotel_delta_old0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Hotel_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_Hotel_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1430
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_notableFeatures_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_notableFeatures_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_notableFeatures" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_notableFeatures_delta_old" ON "dbrdf_notableFeatures_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_notableFeatures_delta_old" ON "dbrdf_notableFeatures_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_notableFeatures_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1431
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sportSpecialty_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sportSpecialty_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_sportSpecialty" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sportSpecialty_delta_old" ON "dbrdf_sportSpecialty_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sportSpecialty_delta_old" ON "dbrdf_sportSpecialty_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sportSpecialty_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1432
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_previousMission_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_previousMission_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_previousMission" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_previousMission_delta_old" ON "dbrdf_previousMission_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_previousMission_delta_old" ON "dbrdf_previousMission_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_previousMission_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1433
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_illustrator_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_illustrator_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_illustrator" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_illustrator_delta_old" ON "dbrdf_illustrator_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_illustrator_delta_old" ON "dbrdf_illustrator_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_illustrator_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1434
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cesarAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cesarAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_cesarAward" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cesarAward_delta_old" ON "dbrdf_cesarAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_cesarAward_delta_old" ON "dbrdf_cesarAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cesarAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1435
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_maidenVoyage_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_maidenVoyage_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_maidenVoyage" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_maidenVoyage_delta_old" ON "dbrdf_maidenVoyage_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_maidenVoyage_delta_old" ON "dbrdf_maidenVoyage_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_maidenVoyage_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1436
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_emedicineSubject_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_emedicineSubject_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_emedicineSubject" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_emedicineSubject_delta_old" ON "dbrdf_emedicineSubject_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_emedicineSubject_delta_old" ON "dbrdf_emedicineSubject_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_emedicineSubject_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1437
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ceeb_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ceeb_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_ceeb" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ceeb_delta_old" ON "dbrdf_ceeb_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ceeb_delta_old" ON "dbrdf_ceeb_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ceeb_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1438
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Insect"(s) SELECT DISTINCT t0.s FROM "dbrdf_Insect_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Insect_delta_old";
        INSERT INTO "dbrdf_Insect_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Insect_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Insect_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1439
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_recentWinner_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_recentWinner_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_recentWinner" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_recentWinner_delta_old" ON "dbrdf_recentWinner_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_recentWinner_delta_old" ON "dbrdf_recentWinner_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_recentWinner_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1440
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_whaDraft_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_whaDraft_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_whaDraft" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_whaDraft_delta_old" ON "dbrdf_whaDraft_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_whaDraft_delta_old" ON "dbrdf_whaDraft_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_whaDraft_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1441
    ---- DEPENDS ON: 1440, 1403, 1368, 980, 709, 627, 393, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/IceHockeyPlayer>(?X) :- <http://dbpedia.org/ontology/hallOfFame>(?X,?X1) .
    INSERT INTO "dbrdf_IceHockeyPlayer"(s) SELECT DISTINCT t0.s FROM "dbrdf_hallOfFame" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_IceHockeyPlayer" 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_IceHockeyPlayer_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_IceHockeyPlayer_delta_old"(s) SELECT t0.s FROM "dbrdf_IceHockeyPlayer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_IceHockeyPlayer_delta_old" ON "dbrdf_IceHockeyPlayer_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_IceHockeyPlayer_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/IceHockeyPlayer$delta_new>(?Y) :- <http://dbpedia.org/ontology/IceHockeyPlayer$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_IceHockeyPlayer_delta_new"(s) SELECT t1.o FROM "dbrdf_IceHockeyPlayer_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_IceHockeyPlayer" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_IceHockeyPlayer"(s) SELECT DISTINCT t0.s FROM "dbrdf_IceHockeyPlayer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_IceHockeyPlayer_delta_old";
        INSERT INTO "dbrdf_IceHockeyPlayer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_IceHockeyPlayer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_IceHockeyPlayer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1442
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_philosophicalSchool_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_philosophicalSchool_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_philosophicalSchool" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_philosophicalSchool_delta_old" ON "dbrdf_philosophicalSchool_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_philosophicalSchool_delta_old" ON "dbrdf_philosophicalSchool_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_philosophicalSchool_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1443
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfUndergraduateStudents_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfUndergraduateStudents_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfUndergraduateStudents" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfUndergraduateStudents_delta_old" ON "dbrdf_numberOfUndergraduateStudents_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfUndergraduateStudents_delta_old" ON "dbrdf_numberOfUndergraduateStudents_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfUndergraduateStudents_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1444
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_tenant_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_tenant_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_tenant" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_tenant_delta_old" ON "dbrdf_tenant_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_tenant_delta_old" ON "dbrdf_tenant_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_tenant_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1445
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1446
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_jointCommunity_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_jointCommunity_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_jointCommunity" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_jointCommunity_delta_old" ON "dbrdf_jointCommunity_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_jointCommunity_delta_old" ON "dbrdf_jointCommunity_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_jointCommunity_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1447
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftAttack_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftAttack_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_aircraftAttack" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftAttack_delta_old" ON "dbrdf_aircraftAttack_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftAttack_delta_old" ON "dbrdf_aircraftAttack_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftAttack_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1448
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_associateStar_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_associateStar_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_associateStar" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_associateStar_delta_old" ON "dbrdf_associateStar_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_associateStar_delta_old" ON "dbrdf_associateStar_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_associateStar_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1449
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_parkingInformation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_parkingInformation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_parkingInformation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_parkingInformation_delta_old" ON "dbrdf_parkingInformation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_parkingInformation_delta_old" ON "dbrdf_parkingInformation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_parkingInformation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1450
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_hairColor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_hairColor_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_hairColor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_hairColor_delta_old" ON "dbrdf_hairColor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_hairColor_delta_old" ON "dbrdf_hairColor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_hairColor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1451
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_introduced_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_introduced_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_introduced" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_introduced_delta_old" ON "dbrdf_introduced_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_introduced_delta_old" ON "dbrdf_introduced_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_introduced_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1452
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Chancellor"(s) SELECT DISTINCT t0.s FROM "dbrdf_Chancellor_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Chancellor_delta_old";
        INSERT INTO "dbrdf_Chancellor_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Chancellor_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Chancellor_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1453
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_missionDuration0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_missionDuration_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_missionDuration_delta_old0";
        INSERT INTO "dbrdf_missionDuration_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_missionDuration_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_missionDuration_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1454
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cargoGas_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cargoGas_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_cargoGas0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cargoGas_delta_old0" ON "dbrdf_cargoGas_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_cargoGas_delta_old0" ON "dbrdf_cargoGas_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cargoGas_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1455
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_alliance_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_alliance_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_alliance" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_alliance_delta_old" ON "dbrdf_alliance_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_alliance_delta_old" ON "dbrdf_alliance_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_alliance_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1456
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_gridReference_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_gridReference_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_gridReference" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_gridReference_delta_old" ON "dbrdf_gridReference_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_gridReference_delta_old" ON "dbrdf_gridReference_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_gridReference_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1457
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_youthClub_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_youthClub_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_youthClub" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_youthClub_delta_old" ON "dbrdf_youthClub_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_youthClub_delta_old" ON "dbrdf_youthClub_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_youthClub_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1458
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_SoccerClubSeason"(s) SELECT DISTINCT t0.s FROM "dbrdf_SoccerClubSeason_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SoccerClubSeason_delta_old";
        INSERT INTO "dbrdf_SoccerClubSeason_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SoccerClubSeason_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SoccerClubSeason_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1459
    ---- DEPENDS ON: 1458, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_SportsTeamSeason_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SportsTeamSeason_delta_old"(s) SELECT t0.s FROM "dbrdf_SportsTeamSeason" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SportsTeamSeason_delta_old" ON "dbrdf_SportsTeamSeason_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SportsTeamSeason_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1460
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dockedTime_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dockedTime_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_dockedTime0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dockedTime_delta_old0" ON "dbrdf_dockedTime_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_dockedTime_delta_old0" ON "dbrdf_dockedTime_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dockedTime_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1461
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1462
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_fastestDriverCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_fastestDriverCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_fastestDriverCountry" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_fastestDriverCountry_delta_old" ON "dbrdf_fastestDriverCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_fastestDriverCountry_delta_old" ON "dbrdf_fastestDriverCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_fastestDriverCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1463
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_broadcastArea_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_broadcastArea_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_broadcastArea" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_broadcastArea_delta_old" ON "dbrdf_broadcastArea_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_broadcastArea_delta_old" ON "dbrdf_broadcastArea_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_broadcastArea_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1464
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_centuryBreaks_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_centuryBreaks_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_centuryBreaks" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_centuryBreaks_delta_old" ON "dbrdf_centuryBreaks_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_centuryBreaks_delta_old" ON "dbrdf_centuryBreaks_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_centuryBreaks_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1465
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_surfaceArea0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_surfaceArea_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_surfaceArea_delta_old0";
        INSERT INTO "dbrdf_surfaceArea_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_surfaceArea_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_surfaceArea_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1466
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1467
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_eurobabeIndexId_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_eurobabeIndexId_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_eurobabeIndexId" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_eurobabeIndexId_delta_old" ON "dbrdf_eurobabeIndexId_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_eurobabeIndexId_delta_old" ON "dbrdf_eurobabeIndexId_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_eurobabeIndexId_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1468
    ---- DEPENDS ON: 1393, 1268, 1114, 1101, 957, 770, 499, 377, 348, 198, 159, 77, 6, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Language>(?X) :- <http://dbpedia.org/ontology/languageFamily>(?X,?X1) .
    INSERT INTO "dbrdf_Language"(s) SELECT DISTINCT t0.s FROM "dbrdf_languageFamily" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Language" 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_Language_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Language_delta_old"(s) SELECT t0.s FROM "dbrdf_Language" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Language_delta_old" ON "dbrdf_Language_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Language_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Language_delta_old0"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Language_delta_old0"(s) SELECT t0.s FROM "dbrdf_Language0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Language_delta_old0" ON "dbrdf_Language_delta_old0"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Language_delta_new0"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Language"(s) SELECT DISTINCT t0.s FROM "dbrdf_Language_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Language_delta_old";
        INSERT INTO "dbrdf_Language_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Language_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Language_delta_new";

        INSERT INTO "dbrdf_Language0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Language_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_Language_delta_old0";
        INSERT INTO "dbrdf_Language_delta_old0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Language_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_Language_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1469
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_distanceTraveled_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_distanceTraveled_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_distanceTraveled" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_distanceTraveled_delta_old" ON "dbrdf_distanceTraveled_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_distanceTraveled_delta_old" ON "dbrdf_distanceTraveled_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_distanceTraveled_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1470
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_neighbourConstellations_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_neighbourConstellations_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_neighbourConstellations" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_neighbourConstellations_delta_old" ON "dbrdf_neighbourConstellations_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_neighbourConstellations_delta_old" ON "dbrdf_neighbourConstellations_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_neighbourConstellations_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1471
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_secondCommander_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_secondCommander_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_secondCommander" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_secondCommander_delta_old" ON "dbrdf_secondCommander_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_secondCommander_delta_old" ON "dbrdf_secondCommander_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_secondCommander_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1472
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1473
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lowestPlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lowestPlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lowestPlace" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lowestPlace_delta_old" ON "dbrdf_lowestPlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lowestPlace_delta_old" ON "dbrdf_lowestPlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lowestPlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1474
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_leaderTitle_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_leaderTitle_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_leaderTitle" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_leaderTitle_delta_old" ON "dbrdf_leaderTitle_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_leaderTitle_delta_old" ON "dbrdf_leaderTitle_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_leaderTitle_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1475
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_frazioni_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_frazioni_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_frazioni" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_frazioni_delta_old" ON "dbrdf_frazioni_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_frazioni_delta_old" ON "dbrdf_frazioni_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_frazioni_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1476
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_unicode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_unicode_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_unicode" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_unicode_delta_old" ON "dbrdf_unicode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_unicode_delta_old" ON "dbrdf_unicode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_unicode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1477
    ---- DEPENDS ON: 1476, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Letter>(?X) :- <http://dbpedia.org/ontology/unicode>(?X,?X1) .
    INSERT INTO "dbrdf_Letter"(s) SELECT DISTINCT t0.s FROM "dbrdf_unicode" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Letter" 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_Letter_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Letter_delta_old"(s) SELECT t0.s FROM "dbrdf_Letter" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Letter_delta_old" ON "dbrdf_Letter_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Letter_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/Letter$delta_new>(?Y) :- <http://dbpedia.org/ontology/Letter$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Letter_delta_new"(s) SELECT t1.o FROM "dbrdf_Letter_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Letter" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Letter"(s) SELECT DISTINCT t0.s FROM "dbrdf_Letter_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Letter_delta_old";
        INSERT INTO "dbrdf_Letter_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Letter_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Letter_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1478
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_computingMedia_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_computingMedia_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_computingMedia" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_computingMedia_delta_old" ON "dbrdf_computingMedia_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_computingMedia_delta_old" ON "dbrdf_computingMedia_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_computingMedia_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1479
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_blockAlloy_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_blockAlloy_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_blockAlloy" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_blockAlloy_delta_old" ON "dbrdf_blockAlloy_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_blockAlloy_delta_old" ON "dbrdf_blockAlloy_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_blockAlloy_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1480
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_totalPopulation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_totalPopulation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_totalPopulation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_totalPopulation_delta_old" ON "dbrdf_totalPopulation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_totalPopulation_delta_old" ON "dbrdf_totalPopulation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_totalPopulation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1481
    ---- DEPENDS ON: 1480, 1276, 625, 259, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_EthnicGroup_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_EthnicGroup_delta_old"(s) SELECT t0.s FROM "dbrdf_EthnicGroup" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_EthnicGroup_delta_old" ON "dbrdf_EthnicGroup_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_EthnicGroup_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1482
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_currentMember_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_currentMember_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_currentMember" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_currentMember_delta_old" ON "dbrdf_currentMember_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_currentMember_delta_old" ON "dbrdf_currentMember_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_currentMember_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1483
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_tournamentRecord_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_tournamentRecord_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_tournamentRecord" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_tournamentRecord_delta_old" ON "dbrdf_tournamentRecord_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_tournamentRecord_delta_old" ON "dbrdf_tournamentRecord_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_tournamentRecord_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1484
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_crews_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_crews_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_crews" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_crews_delta_old" ON "dbrdf_crews_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_crews_delta_old" ON "dbrdf_crews_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_crews_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1485
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_offeredClasses_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_offeredClasses_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_offeredClasses" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_offeredClasses_delta_old" ON "dbrdf_offeredClasses_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_offeredClasses_delta_old" ON "dbrdf_offeredClasses_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_offeredClasses_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1486
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_servingTemperature_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_servingTemperature_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_servingTemperature" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_servingTemperature_delta_old" ON "dbrdf_servingTemperature_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_servingTemperature_delta_old" ON "dbrdf_servingTemperature_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_servingTemperature_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1487
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_premierePlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_premierePlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_premierePlace" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_premierePlace_delta_old" ON "dbrdf_premierePlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_premierePlace_delta_old" ON "dbrdf_premierePlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_premierePlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1488
    ---- DEPENDS ON: 1487, 1282, 1178, 1042, 994, 478, 419, 403, 180, 117, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Play>(?X) :- <http://dbpedia.org/ontology/settingOfPlay>(?X,?X1) .
    INSERT INTO "dbrdf_Play"(s) SELECT DISTINCT t0.s FROM "dbrdf_settingOfPlay" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Play" 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_Play_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Play_delta_old"(s) SELECT t0.s FROM "dbrdf_Play" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Play_delta_old" ON "dbrdf_Play_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Play_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/Play$delta_new>(?Y) :- <http://dbpedia.org/ontology/Play$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Play_delta_new"(s) SELECT t1.o FROM "dbrdf_Play_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Play" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Play"(s) SELECT DISTINCT t0.s FROM "dbrdf_Play_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Play_delta_old";
        INSERT INTO "dbrdf_Play_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Play_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Play_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1489
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_principalEngineer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_principalEngineer_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_principalEngineer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_principalEngineer_delta_old" ON "dbrdf_principalEngineer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_principalEngineer_delta_old" ON "dbrdf_principalEngineer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_principalEngineer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1490
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_footedness_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_footedness_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_footedness" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_footedness_delta_old" ON "dbrdf_footedness_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_footedness_delta_old" ON "dbrdf_footedness_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_footedness_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1491
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1492
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_discovered_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_discovered_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_discovered" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_discovered_delta_old" ON "dbrdf_discovered_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_discovered_delta_old" ON "dbrdf_discovered_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_discovered_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1493
    ---- DEPENDS ON: 1316, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/MusicGenreR>(?X,?X) :- <http://dbpedia.org/ontology/MusicGenre>(?X) .
    INSERT INTO "dbrdf_MusicGenreR"(s, o) SELECT DISTINCT t0.s, t0.s FROM "dbrdf_MusicGenre" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_MusicGenreR" ex WHERE ex.s = t0.s AND ex.o = 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_MusicGenreR_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_MusicGenreR_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_MusicGenreR" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_MusicGenreR_delta_old" ON "dbrdf_MusicGenreR_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_MusicGenreR_delta_old" ON "dbrdf_MusicGenreR_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_MusicGenreR_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1494
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_genre_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_genre_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_genre" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_genre_delta_old" ON "dbrdf_genre_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_genre_delta_old" ON "dbrdf_genre_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_genre_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1495
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Asteroid"(s) SELECT DISTINCT t0.s FROM "dbrdf_Asteroid_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Asteroid_delta_old";
        INSERT INTO "dbrdf_Asteroid_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Asteroid_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Asteroid_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1496
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_logo_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_logo_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_logo" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_logo_delta_old" ON "dbrdf_logo_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_logo_delta_old" ON "dbrdf_logo_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_logo_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1497
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_utcOffset_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_utcOffset_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_utcOffset" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_utcOffset_delta_old" ON "dbrdf_utcOffset_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_utcOffset_delta_old" ON "dbrdf_utcOffset_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_utcOffset_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1498
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_width1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_width_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_width_delta_old1";
        INSERT INTO "dbrdf_width_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_width_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_width_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1499
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1500
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_illiteracy_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_illiteracy_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_illiteracy" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_illiteracy_delta_old" ON "dbrdf_illiteracy_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_illiteracy_delta_old" ON "dbrdf_illiteracy_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_illiteracy_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1501
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceConfluenceState_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sourceConfluenceState_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_sourceConfluenceState" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sourceConfluenceState_delta_old" ON "dbrdf_sourceConfluenceState_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sourceConfluenceState_delta_old" ON "dbrdf_sourceConfluenceState_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceConfluenceState_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1502
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

