    CREATE INDEX "IDX_0_dbrdf_photographer_delta_old" ON "dbrdf_photographer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_photographer_delta_old" ON "dbrdf_photographer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_photographer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1921
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_party_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_party_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_party" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_party_delta_old" ON "dbrdf_party_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_party_delta_old" ON "dbrdf_party_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_party_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1922
    ---- DEPENDS ON: 1921, 1519, 1375, 1158, 1153, 1079, 967, 818, 804, 638, 523, 489, 451, 328, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/PoliticalParty>(?X1) :- <http://dbpedia.org/ontology/politicalPartyOfLeader>(?X,?X1) .
    INSERT INTO "dbrdf_PoliticalParty"(s) SELECT DISTINCT t0.o FROM "dbrdf_politicalPartyOfLeader" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_PoliticalParty" 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_PoliticalParty_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_PoliticalParty_delta_old"(s) SELECT t0.s FROM "dbrdf_PoliticalParty" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_PoliticalParty_delta_old" ON "dbrdf_PoliticalParty_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_PoliticalParty_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/PoliticalParty$delta_new>(?Y) :- <http://dbpedia.org/ontology/PoliticalParty$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_PoliticalParty_delta_new"(s) SELECT t1.o FROM "dbrdf_PoliticalParty_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_PoliticalParty" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_PoliticalParty"(s) SELECT DISTINCT t0.s FROM "dbrdf_PoliticalParty_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_PoliticalParty_delta_old";
        INSERT INTO "dbrdf_PoliticalParty_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_PoliticalParty_delta_new" t0;
        TRUNCATE TABLE "dbrdf_PoliticalParty_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1923
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_TennisTournament"(s) SELECT DISTINCT t0.s FROM "dbrdf_TennisTournament_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_TennisTournament_delta_old";
        INSERT INTO "dbrdf_TennisTournament_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_TennisTournament_delta_new" t0;
        TRUNCATE TABLE "dbrdf_TennisTournament_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1924
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_isbn_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_isbn_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_isbn" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_isbn_delta_old" ON "dbrdf_isbn_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_isbn_delta_old" ON "dbrdf_isbn_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_isbn_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1925
    ---- DEPENDS ON: 1924, 1833, 1433, 1233, 906, 661, 461, 332, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Book>(?X) :- <http://dbpedia.org/ontology/dcc>(?X,?X1) .
    INSERT INTO "dbrdf_Book0"(s) SELECT DISTINCT t0.s FROM "dbrdf_dcc" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Book0" 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_Book_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Book_delta_old"(s) SELECT t0.s FROM "dbrdf_Book" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Book_delta_old" ON "dbrdf_Book_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Book_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Book_delta_old0"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Book_delta_old0"(s) SELECT t0.s FROM "dbrdf_Book1" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Book_delta_old0" ON "dbrdf_Book_delta_old0"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Book_delta_new0"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Book_delta_old1"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Book_delta_old1"(s) SELECT t0.s FROM "dbrdf_Book0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Book_delta_old1" ON "dbrdf_Book_delta_old1"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Book_delta_new1"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://purl.org/ontology/bibo/Book$delta_new>(?X) :- <http://dbpedia.org/ontology/Book$delta_old>(?X) .
        INSERT INTO "dbrdf_Book_delta_new"(s) SELECT t0.s FROM "dbrdf_Book_delta_old1" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Book" ex WHERE ex.s = t0.s);


        -- <http://purl.org/ontology/bibo/Book$delta_new>(?Y) :- <http://purl.org/ontology/bibo/Book$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Book_delta_new"(s) SELECT t1.o FROM "dbrdf_Book_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Book" ex WHERE ex.s = t1.o);


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


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


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


        -- <http://dbpedia.org/ontology/Book$delta_new>(?X) :- <http://purl.org/ontology/bibo/Book$delta_old>(?X) .
        INSERT INTO "dbrdf_Book_delta_new1"(s) SELECT t0.s FROM "dbrdf_Book_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Book0" ex WHERE ex.s = t0.s);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Book"(s) SELECT DISTINCT t0.s FROM "dbrdf_Book_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Book_delta_old";
        INSERT INTO "dbrdf_Book_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Book_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Book_delta_new";

        INSERT INTO "dbrdf_Book1"(s) SELECT DISTINCT t0.s FROM "dbrdf_Book_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_Book_delta_old0";
        INSERT INTO "dbrdf_Book_delta_old0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Book_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_Book_delta_new0";

        INSERT INTO "dbrdf_Book0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Book_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_Book_delta_old1";
        INSERT INTO "dbrdf_Book_delta_old1"(s) SELECT DISTINCT t0.s FROM "dbrdf_Book_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_Book_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1926
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsInEurope_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsInEurope_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_winsInEurope" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsInEurope_delta_old" ON "dbrdf_winsInEurope_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsInEurope_delta_old" ON "dbrdf_winsInEurope_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsInEurope_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1927
    ---- DEPENDS ON: 1926, 1867, 1838, 1321, 1278, 1185, 1126, 984, 882, 689, 680, 527, 525, 340, 257, 251, 167, 142, 34, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/GolfPlayer>(?X) :- <http://dbpedia.org/ontology/winsAtMajors>(?X,?X1) .
    INSERT INTO "dbrdf_GolfPlayer"(s) SELECT DISTINCT t0.s FROM "dbrdf_winsAtMajors" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_GolfPlayer" 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_GolfPlayer_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_GolfPlayer_delta_old"(s) SELECT t0.s FROM "dbrdf_GolfPlayer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_GolfPlayer_delta_old" ON "dbrdf_GolfPlayer_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_GolfPlayer_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/GolfPlayer$delta_new>(?Y) :- <http://dbpedia.org/ontology/GolfPlayer$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_GolfPlayer_delta_new"(s) SELECT t1.o FROM "dbrdf_GolfPlayer_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_GolfPlayer" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_GolfPlayer"(s) SELECT DISTINCT t0.s FROM "dbrdf_GolfPlayer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_GolfPlayer_delta_old";
        INSERT INTO "dbrdf_GolfPlayer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_GolfPlayer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_GolfPlayer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1928
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_VolleyballLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_VolleyballLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_VolleyballLeague_delta_old";
        INSERT INTO "dbrdf_VolleyballLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_VolleyballLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_VolleyballLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1929
    ---- DEPENDS ON: 1928, 1912, 1790, 1620, 1420, 1417, 1194, 1193, 1149, 1082, 1069, 1045, 1021, 1005, 985, 899, 851, 1862, 739, 713, 657, 502, 443, 399, 366, 350, 333, 126, 59, 56, 1237, 16, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/SportsLeague>(?X) :- <http://dbpedia.org/ontology/VideogamesLeague>(?X) .
    INSERT INTO "dbrdf_SportsLeague"(s) SELECT t0.s FROM "dbrdf_VideogamesLeague" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_SportsLeague" 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_SportsLeague_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SportsLeague_delta_old"(s) SELECT t0.s FROM "dbrdf_SportsLeague" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SportsLeague_delta_old" ON "dbrdf_SportsLeague_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SportsLeague_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/SportsLeague$delta_new>(?Y) :- <http://dbpedia.org/ontology/SportsLeague$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_SportsLeague_delta_new"(s) SELECT t1.o FROM "dbrdf_SportsLeague_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_SportsLeague" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_SportsLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_SportsLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SportsLeague_delta_old";
        INSERT INTO "dbrdf_SportsLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SportsLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SportsLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1930
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Reptile"(s) SELECT DISTINCT t0.s FROM "dbrdf_Reptile_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Reptile_delta_old";
        INSERT INTO "dbrdf_Reptile_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Reptile_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Reptile_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1931
    ---- DEPENDS ON: 1930, 1853, 1438, 1177, 1033, 1003, 914, 877, 862, 777, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Animal"(s) SELECT DISTINCT t0.s FROM "dbrdf_Animal_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Animal_delta_old";
        INSERT INTO "dbrdf_Animal_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Animal_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Animal_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1932
    ---- DEPENDS ON: 1931, 1903, 193, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

    -- [Rule] <http://dbpedia.org/ontology/Eukaryote>(?X) :- <http://dbpedia.org/ontology/Fungus>(?X) .
    INSERT INTO "dbrdf_Eukaryote"(s) SELECT t0.s FROM "dbrdf_Fungus" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Eukaryote" 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_Eukaryote_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Eukaryote_delta_old"(s) SELECT t0.s FROM "dbrdf_Eukaryote" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Eukaryote_delta_old" ON "dbrdf_Eukaryote_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Eukaryote_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/Eukaryote$delta_new>(?Y) :- <http://dbpedia.org/ontology/Eukaryote$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Eukaryote_delta_new"(s) SELECT t1.o FROM "dbrdf_Eukaryote_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Eukaryote" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Eukaryote"(s) SELECT DISTINCT t0.s FROM "dbrdf_Eukaryote_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Eukaryote_delta_old";
        INSERT INTO "dbrdf_Eukaryote_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Eukaryote_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Eukaryote_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1933
    ---- DEPENDS ON: 1712, 1932, 1618, 1581, 1547, 1357, 1287, 919, 723, 145, 57, 46, 39, 31, 7, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Species>(?X) :- <http://dbpedia.org/ontology/genus>(?X,?X1) .
    INSERT INTO "dbrdf_Species"(s) SELECT DISTINCT t0.s FROM "dbrdf_genus" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Species" 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_Species_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Species_delta_old"(s) SELECT t0.s FROM "dbrdf_Species" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Species_delta_old" ON "dbrdf_Species_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Species_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/Species$delta_new>(?Y) :- <http://dbpedia.org/ontology/Species$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Species_delta_new"(s) SELECT t1.o FROM "dbrdf_Species_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Species" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Species"(s) SELECT DISTINCT t0.s FROM "dbrdf_Species_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Species_delta_old";
        INSERT INTO "dbrdf_Species_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Species_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Species_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1934
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_distanceToDublin_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_distanceToDublin_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_distanceToDublin" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_distanceToDublin_delta_old" ON "dbrdf_distanceToDublin_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_distanceToDublin_delta_old" ON "dbrdf_distanceToDublin_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_distanceToDublin_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1935
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_city_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_city_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_city" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_city_delta_old" ON "dbrdf_city_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_city_delta_old" ON "dbrdf_city_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_city_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1936
    ---- DEPENDS ON: 1935, 1718, 1668, 1091, 1022, 813, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/City>(?X1) :- <http://dbpedia.org/ontology/beltwayCity>(?X,?X1) .
    INSERT INTO "dbrdf_City0"(s) SELECT DISTINCT t0.o FROM "dbrdf_beltwayCity" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_City0" 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_City_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_City_delta_old"(s) SELECT t0.s FROM "dbrdf_City" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_City_delta_old" ON "dbrdf_City_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_City_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_City_delta_old0"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_City_delta_old0"(s) SELECT t0.s FROM "dbrdf_City0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_City_delta_old0" ON "dbrdf_City_delta_old0"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_City_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/City$delta_new>(?X) :- <http://dbpedia.org/ontology/City$delta_old>(?X) .
        INSERT INTO "dbrdf_City_delta_new"(s) SELECT t0.s FROM "dbrdf_City_delta_old0" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_City" ex WHERE ex.s = t0.s);


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


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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_City"(s) SELECT DISTINCT t0.s FROM "dbrdf_City_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_City_delta_old";
        INSERT INTO "dbrdf_City_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_City_delta_new" t0;
        TRUNCATE TABLE "dbrdf_City_delta_new";

        INSERT INTO "dbrdf_City0"(s) SELECT DISTINCT t0.s FROM "dbrdf_City_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_City_delta_old0";
        INSERT INTO "dbrdf_City_delta_old0"(s) SELECT DISTINCT t0.s FROM "dbrdf_City_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_City_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1937
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_certification_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_certification_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_certification" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_certification_delta_old" ON "dbrdf_certification_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_certification_delta_old" ON "dbrdf_certification_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_certification_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1938
    ---- DEPENDS ON: 1937, 1735, 1348, 549, 485, 163, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Single>(?X) :- <http://dbpedia.org/ontology/certificationDate>(?X,?X1) .
    INSERT INTO "dbrdf_Single"(s) SELECT DISTINCT t0.s FROM "dbrdf_certificationDate" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Single" 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_Single_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Single_delta_old"(s) SELECT t0.s FROM "dbrdf_Single" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Single_delta_old" ON "dbrdf_Single_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Single_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/Single$delta_new>(?Y) :- <http://dbpedia.org/ontology/Single$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Single_delta_new"(s) SELECT t1.o FROM "dbrdf_Single_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Single" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Single"(s) SELECT DISTINCT t0.s FROM "dbrdf_Single_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Single_delta_old";
        INSERT INTO "dbrdf_Single_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Single_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Single_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1939
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nationalRanking_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nationalRanking_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_nationalRanking" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nationalRanking_delta_old" ON "dbrdf_nationalRanking_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nationalRanking_delta_old" ON "dbrdf_nationalRanking_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nationalRanking_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1940
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1941
    ---- DEPENDS ON: 0, 1257, 1161, 1056, 778, 754, 649, 547, 398
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Automobile>(?X) :- <http://dbpedia.org/ontology/wheelbase>(?X,?X1) .
    INSERT INTO "dbrdf_Automobile"(s) SELECT DISTINCT t0.s FROM "dbrdf_wheelbase" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Automobile" 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_Automobile_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Automobile_delta_old"(s) SELECT t0.s FROM "dbrdf_Automobile" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Automobile_delta_old" ON "dbrdf_Automobile_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Automobile_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/Automobile$delta_new>(?Y) :- <http://dbpedia.org/ontology/Automobile$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Automobile_delta_new"(s) SELECT t1.o FROM "dbrdf_Automobile_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Automobile" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Automobile"(s) SELECT DISTINCT t0.s FROM "dbrdf_Automobile_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Automobile_delta_old";
        INSERT INTO "dbrdf_Automobile_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Automobile_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Automobile_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1942
    ---- DEPENDS ON: 1857, 1738, 1380, 1034, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Monarch>(?X) :- <http://dbpedia.org/ontology/placeOfBurial>(?X,?X1) .
    INSERT INTO "dbrdf_Monarch"(s) SELECT DISTINCT t0.s FROM "dbrdf_placeOfBurial" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Monarch" 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_Monarch_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Monarch_delta_old"(s) SELECT t0.s FROM "dbrdf_Monarch" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Monarch_delta_old" ON "dbrdf_Monarch_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Monarch_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/Monarch$delta_new>(?Y) :- <http://dbpedia.org/ontology/Monarch$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Monarch_delta_new"(s) SELECT t1.o FROM "dbrdf_Monarch_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Monarch" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Monarch"(s) SELECT DISTINCT t0.s FROM "dbrdf_Monarch_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Monarch_delta_old";
        INSERT INTO "dbrdf_Monarch_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Monarch_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Monarch_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1943
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_specialist_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_specialist_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_specialist" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_specialist_delta_old" ON "dbrdf_specialist_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_specialist_delta_old" ON "dbrdf_specialist_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_specialist_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1944
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfPads_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfPads_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfPads" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfPads_delta_old" ON "dbrdf_numberOfPads_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfPads_delta_old" ON "dbrdf_numberOfPads_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfPads_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1945
    ---- DEPENDS ON: 1944, 1628, 1411, 1220, 1103, 952, 930, 477, 127, 123, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/LaunchPad>(?X) :- <http://dbpedia.org/ontology/firstLaunchRocket>(?X,?X1) .
    INSERT INTO "dbrdf_LaunchPad"(s) SELECT DISTINCT t0.s FROM "dbrdf_firstLaunchRocket" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_LaunchPad" 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_LaunchPad_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_LaunchPad_delta_old"(s) SELECT t0.s 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);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_LaunchPad_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/LaunchPad$delta_new>(?Y) :- <http://dbpedia.org/ontology/LaunchPad$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_LaunchPad_delta_new"(s) SELECT t1.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);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_LaunchPad"(s) SELECT DISTINCT t0.s 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) SELECT DISTINCT t0.s FROM "dbrdf_LaunchPad_delta_new" t0;
        TRUNCATE TABLE "dbrdf_LaunchPad_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1946
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_constructionMaterial_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_constructionMaterial_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_constructionMaterial" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_constructionMaterial_delta_old" ON "dbrdf_constructionMaterial_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_constructionMaterial_delta_old" ON "dbrdf_constructionMaterial_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_constructionMaterial_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1947
    ---- DEPENDS ON: 1579, 1231, 33, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Locomotive_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Locomotive_delta_old"(s) SELECT t0.s FROM "dbrdf_Locomotive" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Locomotive_delta_old" ON "dbrdf_Locomotive_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Locomotive_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1948
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_spurType_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_spurType_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_spurType" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_spurType_delta_old" ON "dbrdf_spurType_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_spurType_delta_old" ON "dbrdf_spurType_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_spurType_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1949
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_campusSize0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_campusSize_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_campusSize_delta_old0";
        INSERT INTO "dbrdf_campusSize_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_campusSize_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_campusSize_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1950
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_battle_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_battle_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_battle" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_battle_delta_old" ON "dbrdf_battle_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_battle_delta_old" ON "dbrdf_battle_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_battle_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1951
    ---- DEPENDS ON: 1950, 1605, 1213, 1180, 1094, 1087, 1024, 581, 214, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/MilitaryConflict>(?X) :- <http://dbpedia.org/ontology/causalties>(?X,?X1) .
    INSERT INTO "dbrdf_MilitaryConflict"(s) SELECT DISTINCT t0.s FROM "dbrdf_causalties" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_MilitaryConflict" 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_MilitaryConflict_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_MilitaryConflict_delta_old"(s) SELECT t0.s FROM "dbrdf_MilitaryConflict" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_MilitaryConflict_delta_old" ON "dbrdf_MilitaryConflict_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_MilitaryConflict_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/MilitaryConflict$delta_new>(?Y) :- <http://dbpedia.org/ontology/MilitaryConflict$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_MilitaryConflict_delta_new"(s) SELECT t1.o FROM "dbrdf_MilitaryConflict_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_MilitaryConflict" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_MilitaryConflict"(s) SELECT DISTINCT t0.s FROM "dbrdf_MilitaryConflict_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_MilitaryConflict_delta_old";
        INSERT INTO "dbrdf_MilitaryConflict_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_MilitaryConflict_delta_new" t0;
        TRUNCATE TABLE "dbrdf_MilitaryConflict_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1952
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_icdo_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_icdo_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_icdo" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_icdo_delta_old" ON "dbrdf_icdo_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_icdo_delta_old" ON "dbrdf_icdo_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_icdo_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1953
    ---- DEPENDS ON: 1952, 1436, 860, 595, 584, 476, 433, 404, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Disease>(?X) :- <http://dbpedia.org/ontology/medlineplus>(?X,?X1) .
    INSERT INTO "dbrdf_Disease"(s) SELECT DISTINCT t0.s FROM "dbrdf_medlineplus" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Disease" 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_Disease_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Disease_delta_old"(s) SELECT t0.s FROM "dbrdf_Disease" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Disease_delta_old" ON "dbrdf_Disease_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Disease_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/Disease$delta_new>(?Y) :- <http://dbpedia.org/ontology/Disease$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Disease_delta_new"(s) SELECT t1.o FROM "dbrdf_Disease_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Disease" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Disease"(s) SELECT DISTINCT t0.s FROM "dbrdf_Disease_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Disease_delta_old";
        INSERT INTO "dbrdf_Disease_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Disease_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Disease_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1954
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_march_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_march_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_march" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_march_delta_old" ON "dbrdf_march_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_march_delta_old" ON "dbrdf_march_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_march_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1955
    ---- DEPENDS ON: 1954, 1744, 1635, 1182, 1129, 295, 1938, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/MusicalWork>(?X) :- <http://dbpedia.org/ontology/recordedIn>(?X,?X1) .
    INSERT INTO "dbrdf_MusicalWork"(s) SELECT DISTINCT t0.s FROM "dbrdf_recordedIn" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_MusicalWork" 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_MusicalWork_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_MusicalWork_delta_old"(s) SELECT t0.s FROM "dbrdf_MusicalWork" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_MusicalWork_delta_old" ON "dbrdf_MusicalWork_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_MusicalWork_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/MusicalWork$delta_new>(?Y) :- <http://dbpedia.org/ontology/MusicalWork$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_MusicalWork_delta_new"(s) SELECT t1.o FROM "dbrdf_MusicalWork_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_MusicalWork" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_MusicalWork"(s) SELECT DISTINCT t0.s FROM "dbrdf_MusicalWork_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_MusicalWork_delta_old";
        INSERT INTO "dbrdf_MusicalWork_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_MusicalWork_delta_new" t0;
        TRUNCATE TABLE "dbrdf_MusicalWork_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1956
    ---- DEPENDS ON: 1955, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/MusicalWorkR>(?X,?X) :- <http://dbpedia.org/ontology/MusicalWork>(?X) .
    INSERT INTO "dbrdf_MusicalWorkR"(s, o) SELECT DISTINCT t0.s, t0.s FROM "dbrdf_MusicalWork" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_MusicalWorkR" 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_MusicalWorkR_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_MusicalWorkR_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_MusicalWorkR" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_MusicalWorkR_delta_old" ON "dbrdf_MusicalWorkR_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_MusicalWorkR_delta_old" ON "dbrdf_MusicalWorkR_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_MusicalWorkR_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1957
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_leaderParty_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_leaderParty_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_leaderParty" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_leaderParty_delta_old" ON "dbrdf_leaderParty_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_leaderParty_delta_old" ON "dbrdf_leaderParty_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_leaderParty_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1958
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_archipelago_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_archipelago_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_archipelago" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_archipelago_delta_old" ON "dbrdf_archipelago_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_archipelago_delta_old" ON "dbrdf_archipelago_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_archipelago_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1959
    ---- DEPENDS ON: 1958, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Atoll>(?X) :- <http://dbpedia.org/ontology/archipelago>(?X,?X1) .
    INSERT INTO "dbrdf_Atoll"(s) SELECT DISTINCT t0.s FROM "dbrdf_archipelago" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Atoll" 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_Atoll_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Atoll_delta_old"(s) SELECT t0.s FROM "dbrdf_Atoll" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Atoll_delta_old" ON "dbrdf_Atoll_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Atoll_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/Atoll$delta_new>(?Y) :- <http://dbpedia.org/ontology/Atoll$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Atoll_delta_new"(s) SELECT t1.o FROM "dbrdf_Atoll_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Atoll" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Atoll"(s) SELECT DISTINCT t0.s FROM "dbrdf_Atoll_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Atoll_delta_old";
        INSERT INTO "dbrdf_Atoll_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Atoll_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Atoll_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1960
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_activeYearsEndDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_activeYearsEndDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_activeYearsEndDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_activeYearsEndDate_delta_old" ON "dbrdf_activeYearsEndDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_activeYearsEndDate_delta_old" ON "dbrdf_activeYearsEndDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_activeYearsEndDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1961
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_MusicFestival"(s) SELECT DISTINCT t0.s FROM "dbrdf_MusicFestival_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_MusicFestival_delta_old";
        INSERT INTO "dbrdf_MusicFestival_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_MusicFestival_delta_new" t0;
        TRUNCATE TABLE "dbrdf_MusicFestival_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1962
    ---- DEPENDS ON: 1961, 1300, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- [Rule] <http://schema.org/Festival>(?X) :- <http://dbpedia.org/ontology/FilmFestival>(?X) .
    INSERT INTO "dbrdf_Festival"(s) SELECT t0.s FROM "dbrdf_FilmFestival" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Festival" 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_Festival_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Festival_delta_old"(s) SELECT t0.s FROM "dbrdf_Festival" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Festival_delta_old" ON "dbrdf_Festival_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Festival_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Festival"(s) SELECT DISTINCT t0.s FROM "dbrdf_Festival_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Festival_delta_old";
        INSERT INTO "dbrdf_Festival_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Festival_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Festival_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1963
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_europeanUnionEntranceDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_europeanUnionEntranceDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_europeanUnionEntranceDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_europeanUnionEntranceDate_delta_old" ON "dbrdf_europeanUnionEntranceDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_europeanUnionEntranceDate_delta_old" ON "dbrdf_europeanUnionEntranceDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_europeanUnionEntranceDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1964
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1965
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_previousWork_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_previousWork_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_previousWork" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_previousWork_delta_old" ON "dbrdf_previousWork_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_previousWork_delta_old" ON "dbrdf_previousWork_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_previousWork_old"(s integer, o integer) ON COMMIT DROP;
    CREATE INDEX "IDX_0_dbrdf_previousWork_old" ON "dbrdf_previousWork_old"(s, o); CREATE INDEX "IDX_1_dbrdf_previousWork_old" ON "dbrdf_previousWork_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_previousWork_delta_new"(s integer, o integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_subsequentWork_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_subsequentWork_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_subsequentWork" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_subsequentWork_delta_old" ON "dbrdf_subsequentWork_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_subsequentWork_delta_old" ON "dbrdf_subsequentWork_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_subsequentWork_old"(s integer, o integer) ON COMMIT DROP;
    CREATE INDEX "IDX_0_dbrdf_subsequentWork_old" ON "dbrdf_subsequentWork_old"(s, o); CREATE INDEX "IDX_1_dbrdf_subsequentWork_old" ON "dbrdf_subsequentWork_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_subsequentWork_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/previousWork$delta_new>(?X,?Z) :- <http://dbpedia.org/ontology/previousWork$delta_old>(?X,?Y), <http://dbpedia.org/ontology/previousWork>(?Y,?Z) .
        INSERT INTO "dbrdf_previousWork_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_previousWork_delta_old" t0, "dbrdf_previousWork" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_previousWork" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- <http://dbpedia.org/ontology/previousWork$delta_new>(?X,?Z) :- <http://dbpedia.org/ontology/previousWork>(?X,?Y), <http://dbpedia.org/ontology/previousWork$delta_old>(?Y,?Z) .
        INSERT INTO "dbrdf_previousWork_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_previousWork" t0, "dbrdf_previousWork_delta_old" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_previousWork" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- <http://dbpedia.org/ontology/previousWork$delta_new>(?X,?Y) :- <http://dbpedia.org/ontology/subsequentWork$delta_old>(?Y,?X) .
        INSERT INTO "dbrdf_previousWork_delta_new"(s, o) SELECT t0.o, t0.s FROM "dbrdf_subsequentWork_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_previousWork" ex WHERE ex.s = t0.o AND ex.o = t0.s);


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


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


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


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


        -- <http://dbpedia.org/ontology/subsequentWork$delta_new>(?X,?Y) :- <http://dbpedia.org/ontology/previousWork$delta_old>(?Y,?X) .
        INSERT INTO "dbrdf_subsequentWork_delta_new"(s, o) SELECT t0.o, t0.s FROM "dbrdf_previousWork_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_subsequentWork" ex WHERE ex.s = t0.o AND ex.o = t0.s);


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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_previousWork_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_previousWork_delta_old" t0;
        INSERT INTO "dbrdf_previousWork"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_previousWork_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_previousWork_delta_old";
        INSERT INTO "dbrdf_previousWork_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_previousWork_delta_new" t0;
        TRUNCATE TABLE "dbrdf_previousWork_delta_new";

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1966
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1967
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_activeYearsStartYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_activeYearsStartYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_activeYearsStartYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_activeYearsStartYear_delta_old" ON "dbrdf_activeYearsStartYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_activeYearsStartYear_delta_old" ON "dbrdf_activeYearsStartYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_activeYearsStartYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1968
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1969
    ---- DEPENDS ON: 1968, 1916, 1851, 1688, 1428, 1395, 1035, 769, 497, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/PersonFunction>(?X1) :- <http://dbpedia.org/ontology/occupation>(?X,?X1) .
    INSERT INTO "dbrdf_PersonFunction"(s) SELECT DISTINCT t0.o FROM "dbrdf_occupation" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_PersonFunction" 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_PersonFunction_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_PersonFunction_delta_old"(s) SELECT t0.s FROM "dbrdf_PersonFunction" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_PersonFunction_delta_old" ON "dbrdf_PersonFunction_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_PersonFunction_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/PersonFunction$delta_new>(?Y) :- <http://dbpedia.org/ontology/PersonFunction$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_PersonFunction_delta_new"(s) SELECT t1.o FROM "dbrdf_PersonFunction_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_PersonFunction" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_PersonFunction"(s) SELECT DISTINCT t0.s FROM "dbrdf_PersonFunction_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_PersonFunction_delta_old";
        INSERT INTO "dbrdf_PersonFunction_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_PersonFunction_delta_new" t0;
        TRUNCATE TABLE "dbrdf_PersonFunction_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1970
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_event_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_event_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_event" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_event_delta_old" ON "dbrdf_event_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_event_delta_old" ON "dbrdf_event_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_event_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1971
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_contractor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_contractor_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_contractor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_contractor_delta_old" ON "dbrdf_contractor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_contractor_delta_old" ON "dbrdf_contractor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_contractor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1972
    ---- DEPENDS ON: 1971, 1808, 1798, 1568, 1563, 1516, 1686, 1402, 1271, 1675, 0, 1174, 1141, 951, 831, 762, 600, 491, 486, 448, 405, 386, 314, 272, 71
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Company>(?X1) :- <http://dbpedia.org/ontology/designCompany>(?X,?X1) .
    INSERT INTO "dbrdf_Company"(s) SELECT DISTINCT t0.o FROM "dbrdf_designCompany" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Company" 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_Company_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Company_delta_old"(s) SELECT t0.s FROM "dbrdf_Company" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Company_delta_old" ON "dbrdf_Company_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Company_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/Company$delta_new>(?Y) :- <http://dbpedia.org/ontology/Company$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Company_delta_new"(s) SELECT t1.o FROM "dbrdf_Company_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Company" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Company"(s) SELECT DISTINCT t0.s FROM "dbrdf_Company_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Company_delta_old";
        INSERT INTO "dbrdf_Company_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Company_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Company_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1973
    ---- DEPENDS ON: 1971, 1840, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- [Rule] <http://dbpedia.org/ontology/Skyscraper>(?X) :- <http://dbpedia.org/ontology/highestBuildingInYear>(?X,?X1) .
    INSERT INTO "dbrdf_Skyscraper"(s) SELECT DISTINCT t0.s FROM "dbrdf_highestBuildingInYear" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Skyscraper" 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_Skyscraper_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Skyscraper_delta_old"(s) SELECT t0.s FROM "dbrdf_Skyscraper" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Skyscraper_delta_old" ON "dbrdf_Skyscraper_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Skyscraper_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/Skyscraper$delta_new>(?Y) :- <http://dbpedia.org/ontology/Skyscraper$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Skyscraper_delta_new"(s) SELECT t1.o FROM "dbrdf_Skyscraper_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Skyscraper" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Skyscraper"(s) SELECT DISTINCT t0.s FROM "dbrdf_Skyscraper_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Skyscraper_delta_old";
        INSERT INTO "dbrdf_Skyscraper_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Skyscraper_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Skyscraper_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1974
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_decay_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_decay_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_decay" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_decay_delta_old" ON "dbrdf_decay_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_decay_delta_old" ON "dbrdf_decay_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_decay_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1975
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_BiologicalDatabase"(s) SELECT DISTINCT t0.s FROM "dbrdf_BiologicalDatabase_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_BiologicalDatabase_delta_old";
        INSERT INTO "dbrdf_BiologicalDatabase_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_BiologicalDatabase_delta_new" t0;
        TRUNCATE TABLE "dbrdf_BiologicalDatabase_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1976
    ---- DEPENDS ON: 1975, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Database>(?X) :- <http://dbpedia.org/ontology/BiologicalDatabase>(?X) .
    INSERT INTO "dbrdf_Database"(s) SELECT t0.s FROM "dbrdf_BiologicalDatabase" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Database" 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_Database_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Database_delta_old"(s) SELECT t0.s FROM "dbrdf_Database" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Database_delta_old" ON "dbrdf_Database_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Database_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/Database$delta_new>(?Y) :- <http://dbpedia.org/ontology/Database$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Database_delta_new"(s) SELECT t1.o FROM "dbrdf_Database_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Database" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Database"(s) SELECT DISTINCT t0.s FROM "dbrdf_Database_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Database_delta_old";
        INSERT INTO "dbrdf_Database_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Database_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Database_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1977
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_MouseGeneLocation"(s) SELECT DISTINCT t0.s FROM "dbrdf_MouseGeneLocation_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_MouseGeneLocation_delta_old";
        INSERT INTO "dbrdf_MouseGeneLocation_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_MouseGeneLocation_delta_new" t0;
        TRUNCATE TABLE "dbrdf_MouseGeneLocation_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1978
    ---- DEPENDS ON: 1977, 1893, 1877, 1273, 843, 634, 435, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/GeneLocation>(?X) :- <http://dbpedia.org/ontology/geneLocationEnd>(?X,?X1) .
    INSERT INTO "dbrdf_GeneLocation"(s) SELECT DISTINCT t0.s FROM "dbrdf_geneLocationEnd" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_GeneLocation" 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_GeneLocation_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_GeneLocation_delta_old"(s) SELECT t0.s FROM "dbrdf_GeneLocation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_GeneLocation_delta_old" ON "dbrdf_GeneLocation_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_GeneLocation_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/GeneLocation$delta_new>(?Y) :- <http://dbpedia.org/ontology/GeneLocation$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_GeneLocation_delta_new"(s) SELECT t1.o FROM "dbrdf_GeneLocation_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_GeneLocation" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_GeneLocation"(s) SELECT DISTINCT t0.s FROM "dbrdf_GeneLocation_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_GeneLocation_delta_old";
        INSERT INTO "dbrdf_GeneLocation_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_GeneLocation_delta_new" t0;
        TRUNCATE TABLE "dbrdf_GeneLocation_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1979
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_medalist_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_medalist_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_medalist" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_medalist_delta_old" ON "dbrdf_medalist_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_medalist_delta_old" ON "dbrdf_medalist_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_medalist_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1980
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_previousEvent_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_previousEvent_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_previousEvent" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_previousEvent_delta_old" ON "dbrdf_previousEvent_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_previousEvent_delta_old" ON "dbrdf_previousEvent_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_previousEvent_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1981
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_distanceToLondon_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_distanceToLondon_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_distanceToLondon" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_distanceToLondon_delta_old" ON "dbrdf_distanceToLondon_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_distanceToLondon_delta_old" ON "dbrdf_distanceToLondon_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_distanceToLondon_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1982
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Church"(s) SELECT DISTINCT t0.s FROM "dbrdf_Church_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Church_delta_old";
        INSERT INTO "dbrdf_Church_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Church_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Church_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1983
    ---- DEPENDS ON: 1982, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/ReligiousBuilding>(?X) :- <http://dbpedia.org/ontology/Church>(?X) .
    INSERT INTO "dbrdf_ReligiousBuilding"(s) SELECT t0.s FROM "dbrdf_Church" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_ReligiousBuilding" 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_ReligiousBuilding_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ReligiousBuilding_delta_old"(s) SELECT t0.s FROM "dbrdf_ReligiousBuilding" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ReligiousBuilding_delta_old" ON "dbrdf_ReligiousBuilding_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ReligiousBuilding_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/ReligiousBuilding$delta_new>(?Y) :- <http://dbpedia.org/ontology/ReligiousBuilding$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_ReligiousBuilding_delta_new"(s) SELECT t1.o FROM "dbrdf_ReligiousBuilding_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_ReligiousBuilding" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_ReligiousBuilding"(s) SELECT DISTINCT t0.s FROM "dbrdf_ReligiousBuilding_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_ReligiousBuilding_delta_old";
        INSERT INTO "dbrdf_ReligiousBuilding_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_ReligiousBuilding_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ReligiousBuilding_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1984
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_model_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_model_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_model" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_model_delta_old" ON "dbrdf_model_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_model_delta_old" ON "dbrdf_model_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_model_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1985
    ---- DEPENDS ON: 1984, 1534, 1239, 1107, 800, 361, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Sales_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Sales_delta_old"(s) SELECT t0.s FROM "dbrdf_Sales" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Sales_delta_old" ON "dbrdf_Sales_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Sales_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1986
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_coden_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_coden_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_coden" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_coden_delta_old" ON "dbrdf_coden_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_coden_delta_old" ON "dbrdf_coden_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_coden_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1987
    ---- DEPENDS ON: 1986, 1607, 1527, 1488, 1339, 1793, 1925, 468, 265, 192, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/WrittenWork>(?X) :- <http://dbpedia.org/ontology/Book>(?X) .
    INSERT INTO "dbrdf_WrittenWork"(s) SELECT t0.s FROM "dbrdf_Book0" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_WrittenWork" 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_WrittenWork_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_WrittenWork_delta_old"(s) SELECT t0.s FROM "dbrdf_WrittenWork" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_WrittenWork_delta_old" ON "dbrdf_WrittenWork_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_WrittenWork_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/WrittenWork$delta_new>(?Y) :- <http://dbpedia.org/ontology/WrittenWork$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_WrittenWork_delta_new"(s) SELECT t1.o FROM "dbrdf_WrittenWork_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_WrittenWork" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_WrittenWork"(s) SELECT DISTINCT t0.s FROM "dbrdf_WrittenWork_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_WrittenWork_delta_old";
        INSERT INTO "dbrdf_WrittenWork_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_WrittenWork_delta_new" t0;
        TRUNCATE TABLE "dbrdf_WrittenWork_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1988
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sixthFormStudents_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sixthFormStudents_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_sixthFormStudents" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sixthFormStudents_delta_old" ON "dbrdf_sixthFormStudents_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sixthFormStudents_delta_old" ON "dbrdf_sixthFormStudents_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sixthFormStudents_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1989
    ---- DEPENDS ON: 1988, 1949, 1943, 1939, 1770, 1742, 1690, 1687, 1684, 1595, 1559, 1557, 1485, 1437, 1410, 1343, 1298, 1225, 1222, 1198, 1176, 1099, 1050, 1041, 1029, 962, 875, 826, 803, 767, 764, 747, 734, 725, 692, 639, 618, 605, 511, 438, 406, 325, 261, 256, 249, 235, 183, 165, 36, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/School>(?X) :- <http://dbpedia.org/ontology/nobelLaureates>(?X,?X1) .
    INSERT INTO "dbrdf_School0"(s) SELECT DISTINCT t0.s FROM "dbrdf_nobelLaureates" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_School0" 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_School_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_School_delta_old"(s) SELECT t0.s FROM "dbrdf_School" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_School_delta_old" ON "dbrdf_School_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_School_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_School_delta_old0"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_School_delta_old0"(s) SELECT t0.s FROM "dbrdf_School0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_School_delta_old0" ON "dbrdf_School_delta_old0"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_School_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/School$delta_new>(?X) :- <http://dbpedia.org/ontology/School$delta_old>(?X) .
        INSERT INTO "dbrdf_School_delta_new"(s) SELECT t0.s FROM "dbrdf_School_delta_old0" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_School" ex WHERE ex.s = t0.s);


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


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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_School"(s) SELECT DISTINCT t0.s FROM "dbrdf_School_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_School_delta_old";
        INSERT INTO "dbrdf_School_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_School_delta_new" t0;
        TRUNCATE TABLE "dbrdf_School_delta_new";

        INSERT INTO "dbrdf_School0"(s) SELECT DISTINCT t0.s FROM "dbrdf_School_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_School_delta_old0";
        INSERT INTO "dbrdf_School_delta_old0"(s) SELECT DISTINCT t0.s FROM "dbrdf_School_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_School_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1990
    ---- DEPENDS ON: 1891, 1989, 1645, 1443, 1648, 1265, 1163, 1089, 1023, 982, 944, 853, 847, 795, 765, 748, 573, 521, 372, 255, 234, 99, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/EducationalInstitution>(?X) :- <http://dbpedia.org/ontology/Library>(?X) .
    INSERT INTO "dbrdf_EducationalInstitution"(s) SELECT t0.s FROM "dbrdf_Library0" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_EducationalInstitution" 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_EducationalOrganization_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_EducationalOrganization_delta_old"(s) SELECT t0.s FROM "dbrdf_EducationalOrganization" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_EducationalOrganization_delta_old" ON "dbrdf_EducationalOrganization_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_EducationalOrganization_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_EducationalInstitution_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_EducationalInstitution_delta_old"(s) SELECT t0.s FROM "dbrdf_EducationalInstitution" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_EducationalInstitution_delta_old" ON "dbrdf_EducationalInstitution_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_EducationalInstitution_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://schema.org/EducationalOrganization$delta_new>(?X) :- <http://dbpedia.org/ontology/EducationalInstitution$delta_old>(?X) .
        INSERT INTO "dbrdf_EducationalOrganization_delta_new"(s) SELECT t0.s FROM "dbrdf_EducationalInstitution_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_EducationalOrganization" ex WHERE ex.s = t0.s);


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


        -- <http://dbpedia.org/ontology/EducationalInstitution$delta_new>(?X) :- <http://schema.org/EducationalOrganization$delta_old>(?X) .
        INSERT INTO "dbrdf_EducationalInstitution_delta_new"(s) SELECT t0.s FROM "dbrdf_EducationalOrganization_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_EducationalInstitution" ex WHERE ex.s = t0.s);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_EducationalOrganization"(s) SELECT DISTINCT t0.s FROM "dbrdf_EducationalOrganization_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_EducationalOrganization_delta_old";
        INSERT INTO "dbrdf_EducationalOrganization_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_EducationalOrganization_delta_new" t0;
        TRUNCATE TABLE "dbrdf_EducationalOrganization_delta_new";

        INSERT INTO "dbrdf_EducationalInstitution"(s) SELECT DISTINCT t0.s FROM "dbrdf_EducationalInstitution_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_EducationalInstitution_delta_old";
        INSERT INTO "dbrdf_EducationalInstitution_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_EducationalInstitution_delta_new" t0;
        TRUNCATE TABLE "dbrdf_EducationalInstitution_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1991
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_canBaggageChecked_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_canBaggageChecked_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_canBaggageChecked" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_canBaggageChecked_delta_old" ON "dbrdf_canBaggageChecked_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_canBaggageChecked_delta_old" ON "dbrdf_canBaggageChecked_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_canBaggageChecked_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1992
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftHelicopterTransport_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftHelicopterTransport_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_aircraftHelicopterTransport" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftHelicopterTransport_delta_old" ON "dbrdf_aircraftHelicopterTransport_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftHelicopterTransport_delta_old" ON "dbrdf_aircraftHelicopterTransport_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftHelicopterTransport_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1993
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumTemperature_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_maximumTemperature_delta_old1"(s, o) SELECT t0.s, t0.o FROM "dbrdf_maximumTemperature1" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_maximumTemperature_delta_old1" ON "dbrdf_maximumTemperature_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_maximumTemperature_delta_old1" ON "dbrdf_maximumTemperature_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumTemperature_delta_new1"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1994
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_grossDomesticProduct_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_grossDomesticProduct_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_grossDomesticProduct" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_grossDomesticProduct_delta_old" ON "dbrdf_grossDomesticProduct_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_grossDomesticProduct_delta_old" ON "dbrdf_grossDomesticProduct_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_grossDomesticProduct_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1995
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_espnId_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_espnId_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_espnId" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_espnId_delta_old" ON "dbrdf_espnId_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_espnId_delta_old" ON "dbrdf_espnId_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_espnId_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1996
    ---- DEPENDS ON: 1794, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/FootballPlayerR>(?X,?X) :- <http://dbpedia.org/ontology/SoccerPlayer>(?X) .
    INSERT INTO "dbrdf_FootballPlayerR"(s, o) SELECT DISTINCT t0.s, t0.s FROM "dbrdf_SoccerPlayer" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_FootballPlayerR" 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_FootballPlayerR_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_FootballPlayerR_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_FootballPlayerR" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_FootballPlayerR_delta_old" ON "dbrdf_FootballPlayerR_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_FootballPlayerR_delta_old" ON "dbrdf_FootballPlayerR_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_FootballPlayerR_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1997
    ---- DEPENDS ON: 1963, 1799, 1785, 1727, 1716, 1663, 1631, 1627, 1574, 1522, 1462, 1424, 1419, 1327, 992, 956, 921, 898, 866, 845, 796, 752, 745, 579, 551, 467, 450, 439, 360, 326, 308, 20, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Country>(?X1) :- <http://dbpedia.org/ontology/usingCountry>(?X,?X1) .
    INSERT INTO "dbrdf_Country"(s) SELECT DISTINCT t0.o FROM "dbrdf_usingCountry" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Country" 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_Country_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Country_delta_old"(s) SELECT t0.s FROM "dbrdf_Country" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Country_delta_old" ON "dbrdf_Country_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Country_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Country_delta_old0"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Country_delta_old0"(s) SELECT t0.s FROM "dbrdf_Country0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Country_delta_old0" ON "dbrdf_Country_delta_old0"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Country_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/Country$delta_new>(?X) :- <http://schema.org/Country$delta_old>(?X) .
        INSERT INTO "dbrdf_Country_delta_new"(s) SELECT t0.s FROM "dbrdf_Country_delta_old0" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Country" ex WHERE ex.s = t0.s);


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


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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Country"(s) SELECT DISTINCT t0.s FROM "dbrdf_Country_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Country_delta_old";
        INSERT INTO "dbrdf_Country_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Country_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Country_delta_new";

        INSERT INTO "dbrdf_Country0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Country_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_Country_delta_old0";
        INSERT INTO "dbrdf_Country_delta_old0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Country_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_Country_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1998
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_associatedMusicalArtist_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_associatedMusicalArtist_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_associatedMusicalArtist" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_associatedMusicalArtist_delta_old" ON "dbrdf_associatedMusicalArtist_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_associatedMusicalArtist_delta_old" ON "dbrdf_associatedMusicalArtist_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_associatedMusicalArtist_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1999
    ---- DEPENDS ON: 1998, 1827, 988, 674, 503, 485, 446, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/MusicalArtist>(?X) :- <http://dbpedia.org/ontology/numberOfLiveAlbums>(?X,?X1) .
    INSERT INTO "dbrdf_MusicalArtist"(s) SELECT DISTINCT t0.s FROM "dbrdf_numberOfLiveAlbums" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_MusicalArtist" 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_MusicalArtist_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_MusicalArtist_delta_old"(s) SELECT t0.s FROM "dbrdf_MusicalArtist" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_MusicalArtist_delta_old" ON "dbrdf_MusicalArtist_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_MusicalArtist_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/MusicalArtist$delta_new>(?Y) :- <http://dbpedia.org/ontology/MusicalArtist$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_MusicalArtist_delta_new"(s) SELECT t1.o FROM "dbrdf_MusicalArtist_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_MusicalArtist" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_MusicalArtist"(s) SELECT DISTINCT t0.s FROM "dbrdf_MusicalArtist_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_MusicalArtist_delta_old";
        INSERT INTO "dbrdf_MusicalArtist_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_MusicalArtist_delta_new" t0;
        TRUNCATE TABLE "dbrdf_MusicalArtist_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 2000
    ---- DEPENDS ON: 1910, 1999, 1847, 1659, 1434, 1381, 1251, 1834, 976, 975, 973, 912, 781, 772, 729, 1855, 628, 588, 339, 284, 234, 82, 1324, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Artist>(?X) :- <http://dbpedia.org/ontology/baftaAward>(?X,?X1) .
    INSERT INTO "dbrdf_Artist"(s) SELECT DISTINCT t0.s FROM "dbrdf_baftaAward" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Artist" 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_Artist_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Artist_delta_old"(s) SELECT t0.s FROM "dbrdf_Artist" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Artist_delta_old" ON "dbrdf_Artist_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Artist_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/Artist$delta_new>(?Y) :- <http://dbpedia.org/ontology/Artist$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Artist_delta_new"(s) SELECT t1.o FROM "dbrdf_Artist_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Artist" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Artist"(s) SELECT DISTINCT t0.s FROM "dbrdf_Artist_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Artist_delta_old";
        INSERT INTO "dbrdf_Artist_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Artist_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Artist_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 2001
    ---- DEPENDS ON: 1999, 1736, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- [Rule] <http://schema.org/MusicGroup>(?X) :- <http://dbpedia.org/ontology/Band>(?X) .
    INSERT INTO "dbrdf_MusicGroup"(s) SELECT t0.s FROM "dbrdf_Band" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_MusicGroup" 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_MusicGroup_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_MusicGroup_delta_old"(s) SELECT t0.s FROM "dbrdf_MusicGroup" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_MusicGroup_delta_old" ON "dbrdf_MusicGroup_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_MusicGroup_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_MusicGroup"(s) SELECT DISTINCT t0.s FROM "dbrdf_MusicGroup_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_MusicGroup_delta_old";
        INSERT INTO "dbrdf_MusicGroup_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_MusicGroup_delta_new" t0;
        TRUNCATE TABLE "dbrdf_MusicGroup_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 2002
    ---- DEPENDS ON: 2001, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://schema.org/MusicGroupR>(?X,?X) :- <http://schema.org/MusicGroup>(?X) .
    INSERT INTO "dbrdf_MusicGroupR"(s, o) SELECT DISTINCT t0.s, t0.s FROM "dbrdf_MusicGroup" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_MusicGroupR" 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_MusicGroupR_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_MusicGroupR_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_MusicGroupR" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_MusicGroupR_delta_old" ON "dbrdf_MusicGroupR_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_MusicGroupR_delta_old" ON "dbrdf_MusicGroupR_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_MusicGroupR_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 2003
    ---- DEPENDS ON: 2002, 1494, 1493, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/musicGroupHasGenre>(?X0,?X3) :- <http://schema.org/MusicGroupR>(?X0,?X1), <http://dbpedia.org/ontology/genre>(?X1,?X2), <http://dbpedia.org/ontology/MusicGenreR>(?X2,?X3) .
    INSERT INTO "dbrdf_musicGroupHasGenre"(s, o) SELECT DISTINCT t0.s, t2.o FROM "dbrdf_MusicGroupR" t0, "dbrdf_genre" t1, "dbrdf_MusicGenreR" t2 WHERE t0.o = t1.s AND t1.o = t2.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_musicGroupHasGenre" ex WHERE ex.s = t0.s AND ex.o = t2.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_musicGroupHasGenre_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_musicGroupHasGenre_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_musicGroupHasGenre" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_musicGroupHasGenre_delta_old" ON "dbrdf_musicGroupHasGenre_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_musicGroupHasGenre_delta_old" ON "dbrdf_musicGroupHasGenre_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_musicGroupHasGenre_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 2004
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_surfaceArea_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_surfaceArea_delta_old1"(s, o) SELECT t0.s, t0.o FROM "dbrdf_surfaceArea1" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_surfaceArea_delta_old1" ON "dbrdf_surfaceArea_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_surfaceArea_delta_old1" ON "dbrdf_surfaceArea_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_surfaceArea_delta_new1"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_surfaceArea1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_surfaceArea_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_surfaceArea_delta_old1";
        INSERT INTO "dbrdf_surfaceArea_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_surfaceArea_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_surfaceArea_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 2005
    ---- DEPENDS ON: 2004, 1993, 1814, 1739, 1705, 1430, 1295, 1280, 1250, 1051, 825, 413, 227, 219, 161, 132, 102, 52, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Galaxy>(?X) :- <http://dbpedia.org/ontology/Galaxy/averageSpeed>(?X,?X1) .
    INSERT INTO "dbrdf_Galaxy"(s) SELECT DISTINCT t0.s FROM "dbrdf_averageSpeed" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Galaxy" 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_Galaxy_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Galaxy_delta_old"(s) SELECT t0.s FROM "dbrdf_Galaxy" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Galaxy_delta_old" ON "dbrdf_Galaxy_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Galaxy_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/Galaxy$delta_new>(?Y) :- <http://dbpedia.org/ontology/Galaxy$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Galaxy_delta_new"(s) SELECT t1.o FROM "dbrdf_Galaxy_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Galaxy" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Galaxy"(s) SELECT DISTINCT t0.s FROM "dbrdf_Galaxy_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Galaxy_delta_old";
        INSERT INTO "dbrdf_Galaxy_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Galaxy_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Galaxy_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 2006
    ---- DEPENDS ON: 1917, 1495, 2005, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

    -- [Rule] <http://dbpedia.org/ontology/CelestialBody>(?X) :- <http://dbpedia.org/ontology/Galaxy>(?X) .
    INSERT INTO "dbrdf_CelestialBody"(s) SELECT t0.s FROM "dbrdf_Galaxy" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_CelestialBody" 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_CelestialBody_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_CelestialBody_delta_old"(s) SELECT t0.s FROM "dbrdf_CelestialBody" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_CelestialBody_delta_old" ON "dbrdf_CelestialBody_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_CelestialBody_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/CelestialBody$delta_new>(?Y) :- <http://dbpedia.org/ontology/CelestialBody$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_CelestialBody_delta_new"(s) SELECT t1.o FROM "dbrdf_CelestialBody_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_CelestialBody" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_CelestialBody"(s) SELECT DISTINCT t0.s FROM "dbrdf_CelestialBody_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_CelestialBody_delta_old";
        INSERT INTO "dbrdf_CelestialBody_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_CelestialBody_delta_new" t0;
        TRUNCATE TABLE "dbrdf_CelestialBody_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 2007
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_geologicPeriod_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_geologicPeriod_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_geologicPeriod" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_geologicPeriod_delta_old" ON "dbrdf_geologicPeriod_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_geologicPeriod_delta_old" ON "dbrdf_geologicPeriod_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_geologicPeriod_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 2008
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_gameEngine_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_gameEngine_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_gameEngine" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_gameEngine_delta_old" ON "dbrdf_gameEngine_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_gameEngine_delta_old" ON "dbrdf_gameEngine_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_gameEngine_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 2009
    ---- DEPENDS ON: 2008, 1076, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- [Rule] <http://dbpedia.org/ontology/VideoGame>(?X) :- <http://dbpedia.org/ontology/gameArtist>(?X,?X1) .
    INSERT INTO "dbrdf_VideoGame"(s) SELECT DISTINCT t0.s FROM "dbrdf_gameArtist" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_VideoGame" 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_VideoGame_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_VideoGame_delta_old"(s) SELECT t0.s FROM "dbrdf_VideoGame" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_VideoGame_delta_old" ON "dbrdf_VideoGame_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_VideoGame_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/VideoGame$delta_new>(?Y) :- <http://dbpedia.org/ontology/VideoGame$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_VideoGame_delta_new"(s) SELECT t1.o FROM "dbrdf_VideoGame_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_VideoGame" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_VideoGame"(s) SELECT DISTINCT t0.s FROM "dbrdf_VideoGame_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_VideoGame_delta_old";
        INSERT INTO "dbrdf_VideoGame_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_VideoGame_delta_new" t0;
        TRUNCATE TABLE "dbrdf_VideoGame_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 2010
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfCounties_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfCounties_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfCounties" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfCounties_delta_old" ON "dbrdf_numberOfCounties_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfCounties_delta_old" ON "dbrdf_numberOfCounties_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfCounties_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 2011
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_totalCargo0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_totalCargo_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_totalCargo_delta_old0";
        INSERT INTO "dbrdf_totalCargo_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_totalCargo_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_totalCargo_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 2012
    ---- DEPENDS ON: 2011, 1974, 1919, 1694, 1592, 1525, 1512, 1460, 1454, 1397, 1307, 1279, 1229, 1195, 1190, 1172, 905, 863, 808, 798, 797, 726, 710, 705, 697, 652, 506, 378, 300, 292, 213, 196, 185, 149, 67, 15, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Spacecraft>(?X) :- <http://dbpedia.org/ontology/Spacecraft/freeFlightTime>(?X,?X1) .
    INSERT INTO "dbrdf_Spacecraft"(s) SELECT DISTINCT t0.s FROM "dbrdf_freeFlightTime" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Spacecraft" 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_Spacecraft_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Spacecraft_delta_old"(s) SELECT t0.s FROM "dbrdf_Spacecraft" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Spacecraft_delta_old" ON "dbrdf_Spacecraft_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Spacecraft_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/Spacecraft$delta_new>(?Y) :- <http://dbpedia.org/ontology/Spacecraft$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Spacecraft_delta_new"(s) SELECT t1.o FROM "dbrdf_Spacecraft_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Spacecraft" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Spacecraft"(s) SELECT DISTINCT t0.s FROM "dbrdf_Spacecraft_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Spacecraft_delta_old";
        INSERT INTO "dbrdf_Spacecraft_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Spacecraft_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Spacecraft_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 2013
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cityType_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cityType_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_cityType" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cityType_delta_old" ON "dbrdf_cityType_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_cityType_delta_old" ON "dbrdf_cityType_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cityType_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 2014
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_scottishName_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_scottishName_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_scottishName" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_scottishName_delta_old" ON "dbrdf_scottishName_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_scottishName_delta_old" ON "dbrdf_scottishName_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_scottishName_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 2015
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_orbitalInclination_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_orbitalInclination_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_orbitalInclination" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_orbitalInclination_delta_old" ON "dbrdf_orbitalInclination_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_orbitalInclination_delta_old" ON "dbrdf_orbitalInclination_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_orbitalInclination_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 2016
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_comparable_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_comparable_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_comparable" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_comparable_delta_old" ON "dbrdf_comparable_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_comparable_delta_old" ON "dbrdf_comparable_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_comparable_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 2017
    ---- DEPENDS ON: 2016, 1726, 1419, 1266, 1220, 1199, 1036, 993, 937, 710, 575, 455, 401, 368, 127, 123, 79, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Rocket>(?X1) :- <http://dbpedia.org/ontology/lastLaunchRocket>(?X,?X1) .
    INSERT INTO "dbrdf_Rocket"(s) SELECT DISTINCT t0.o FROM "dbrdf_lastLaunchRocket" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Rocket" 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_Rocket_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Rocket_delta_old"(s) SELECT t0.s FROM "dbrdf_Rocket" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Rocket_delta_old" ON "dbrdf_Rocket_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Rocket_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/Rocket$delta_new>(?Y) :- <http://dbpedia.org/ontology/Rocket$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Rocket_delta_new"(s) SELECT t1.o FROM "dbrdf_Rocket_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Rocket" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Rocket"(s) SELECT DISTINCT t0.s FROM "dbrdf_Rocket_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Rocket_delta_old";
        INSERT INTO "dbrdf_Rocket_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Rocket_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Rocket_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 2018
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_passengersUsedSystem_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_passengersUsedSystem_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_passengersUsedSystem" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_passengersUsedSystem_delta_old" ON "dbrdf_passengersUsedSystem_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_passengersUsedSystem_delta_old" ON "dbrdf_passengersUsedSystem_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_passengersUsedSystem_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 2019
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_filmAudioType_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_filmAudioType_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_filmAudioType" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_filmAudioType_delta_old" ON "dbrdf_filmAudioType_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_filmAudioType_delta_old" ON "dbrdf_filmAudioType_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_filmAudioType_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 2020
    ---- DEPENDS ON: 2019, 1895, 1698, 1610, 1539, 1511, 1467, 1283, 1256, 1148, 1143, 1142, 1125, 1112, 1039, 971, 913, 816, 759, 402, 373, 216, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Film>(?X) :- <http://dbpedia.org/ontology/costumeDesigner>(?X,?X1) .
