        INSERT INTO "dbrdf_filmFareAward_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_filmFareAward_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26784 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/filmFareAward$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/filmFareAward$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_filmFareAward_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_filmFareAward_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26784 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26784, t0.o FROM "dbrdf_filmFareAward_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_filmFareAward_delta_old";
        INSERT INTO "dbrdf_filmFareAward_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_filmFareAward_delta_new" t0;
        TRUNCATE TABLE "dbrdf_filmFareAward_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 303
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_branchFrom_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_branchFrom_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26785;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_branchFrom_delta_old" ON "dbrdf_branchFrom_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_branchFrom_delta_old" ON "dbrdf_branchFrom_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_branchFrom_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/branchFrom$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/branchFrom$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_branchFrom_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_branchFrom_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26785 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/branchFrom$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/branchFrom$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_branchFrom_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_branchFrom_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26785 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26785, t0.o FROM "dbrdf_branchFrom_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_branchFrom_delta_old";
        INSERT INTO "dbrdf_branchFrom_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_branchFrom_delta_new" t0;
        TRUNCATE TABLE "dbrdf_branchFrom_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 304
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Lieutenant_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Lieutenant_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26786;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Lieutenant_delta_old" ON "dbrdf_Lieutenant_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Lieutenant_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/Lieutenant$delta_new>(?Y) :- <http://dbpedia.org/ontology/Lieutenant$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Lieutenant_delta_new"(s) SELECT t1.o FROM "dbrdf_Lieutenant_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26786);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26786 FROM "dbrdf_Lieutenant_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Lieutenant_delta_old";
        INSERT INTO "dbrdf_Lieutenant_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Lieutenant_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Lieutenant_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 305
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceRegion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sourceRegion_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26787;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sourceRegion_delta_old" ON "dbrdf_sourceRegion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sourceRegion_delta_old" ON "dbrdf_sourceRegion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceRegion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/sourceRegion$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/sourceRegion$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_sourceRegion_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_sourceRegion_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26787 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/sourceRegion$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/sourceRegion$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_sourceRegion_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_sourceRegion_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26787 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26787, t0.o FROM "dbrdf_sourceRegion_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_sourceRegion_delta_old";
        INSERT INTO "dbrdf_sourceRegion_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_sourceRegion_delta_new" t0;
        TRUNCATE TABLE "dbrdf_sourceRegion_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 306
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_politicalPartyInLegislature_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_politicalPartyInLegislature_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26788;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_politicalPartyInLegislature_delta_old" ON "dbrdf_politicalPartyInLegislature_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_politicalPartyInLegislature_delta_old" ON "dbrdf_politicalPartyInLegislature_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_politicalPartyInLegislature_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/politicalPartyInLegislature$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/politicalPartyInLegislature$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_politicalPartyInLegislature_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_politicalPartyInLegislature_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26788 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/politicalPartyInLegislature$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/politicalPartyInLegislature$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_politicalPartyInLegislature_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_politicalPartyInLegislature_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26788 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26788, t0.o FROM "dbrdf_politicalPartyInLegislature_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_politicalPartyInLegislature_delta_old";
        INSERT INTO "dbrdf_politicalPartyInLegislature_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_politicalPartyInLegislature_delta_new" t0;
        TRUNCATE TABLE "dbrdf_politicalPartyInLegislature_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 307
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_company_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_company_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26789;
    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, o); CREATE INDEX "IDX_1_dbrdf_company_delta_old" ON "dbrdf_company_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_company_delta_new"(s integer, o 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,?X1) :- <http://dbpedia.org/ontology/company$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_company_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_company_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26789 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/company$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/company$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_company_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_company_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26789 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 308
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastAirDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lastAirDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26790;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lastAirDate_delta_old" ON "dbrdf_lastAirDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lastAirDate_delta_old" ON "dbrdf_lastAirDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastAirDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/lastAirDate$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/lastAirDate$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_lastAirDate_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_lastAirDate_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26790 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/lastAirDate$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/lastAirDate$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_lastAirDate_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_lastAirDate_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26790 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26790, t0.o FROM "dbrdf_lastAirDate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_lastAirDate_delta_old";
        INSERT INTO "dbrdf_lastAirDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lastAirDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_lastAirDate_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 309
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_locationCity_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_locationCity_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26791;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_locationCity_delta_old" ON "dbrdf_locationCity_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_locationCity_delta_old" ON "dbrdf_locationCity_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_locationCity_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/locationCity$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/locationCity$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_locationCity_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_locationCity_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26791 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/locationCity$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/locationCity$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_locationCity_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_locationCity_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26791 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26791, t0.o FROM "dbrdf_locationCity_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_locationCity_delta_old";
        INSERT INTO "dbrdf_locationCity_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_locationCity_delta_new" t0;
        TRUNCATE TABLE "dbrdf_locationCity_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 310
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_filmPolskiId_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_filmPolskiId_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26792;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_filmPolskiId_delta_old" ON "dbrdf_filmPolskiId_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_filmPolskiId_delta_old" ON "dbrdf_filmPolskiId_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_filmPolskiId_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/filmPolskiId$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/filmPolskiId$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_filmPolskiId_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_filmPolskiId_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26792 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/filmPolskiId$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/filmPolskiId$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_filmPolskiId_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_filmPolskiId_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26792 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26792, t0.o FROM "dbrdf_filmPolskiId_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_filmPolskiId_delta_old";
        INSERT INTO "dbrdf_filmPolskiId_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_filmPolskiId_delta_new" t0;
        TRUNCATE TABLE "dbrdf_filmPolskiId_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 311
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastFlightStartDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lastFlightStartDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26793;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lastFlightStartDate_delta_old" ON "dbrdf_lastFlightStartDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lastFlightStartDate_delta_old" ON "dbrdf_lastFlightStartDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastFlightStartDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/lastFlightStartDate$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/lastFlightStartDate$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_lastFlightStartDate_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_lastFlightStartDate_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26793 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/lastFlightStartDate$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/lastFlightStartDate$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_lastFlightStartDate_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_lastFlightStartDate_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26793 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26793, t0.o FROM "dbrdf_lastFlightStartDate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_lastFlightStartDate_delta_old";
        INSERT INTO "dbrdf_lastFlightStartDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lastFlightStartDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_lastFlightStartDate_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 312
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_carNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_carNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26794;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_carNumber_delta_old" ON "dbrdf_carNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_carNumber_delta_old" ON "dbrdf_carNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_carNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/carNumber$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/carNumber$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_carNumber_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_carNumber_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26794 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/carNumber$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/carNumber$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_carNumber_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_carNumber_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26794 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26794, t0.o FROM "dbrdf_carNumber_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_carNumber_delta_old";
        INSERT INTO "dbrdf_carNumber_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_carNumber_delta_new" t0;
        TRUNCATE TABLE "dbrdf_carNumber_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 313
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_minimumTemperature_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_minimumTemperature_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26795;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_minimumTemperature_delta_old0" ON "dbrdf_minimumTemperature_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_minimumTemperature_delta_old0" ON "dbrdf_minimumTemperature_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_minimumTemperature_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/Galaxy/minimumTemperature$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Galaxy/minimumTemperature$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_minimumTemperature_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_minimumTemperature_delta_old0" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26795 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/Galaxy/minimumTemperature$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/Galaxy/minimumTemperature$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_minimumTemperature_delta_new0"(s, o) SELECT t0.s, t1.o FROM "dbrdf_minimumTemperature_delta_old0" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26795 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26795, t0.o FROM "dbrdf_minimumTemperature_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_minimumTemperature_delta_old0";
        INSERT INTO "dbrdf_minimumTemperature_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_minimumTemperature_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_minimumTemperature_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 314
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_satScore_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_satScore_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26796;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_satScore_delta_old" ON "dbrdf_satScore_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_satScore_delta_old" ON "dbrdf_satScore_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_satScore_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 315
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 316
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 317
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_TradeUnion_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_TradeUnion_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26799;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_TradeUnion_delta_old" ON "dbrdf_TradeUnion_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_TradeUnion_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/TradeUnion$delta_new>(?Y) :- <http://dbpedia.org/ontology/TradeUnion$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_TradeUnion_delta_new"(s) SELECT t1.o FROM "dbrdf_TradeUnion_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26799);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26799 FROM "dbrdf_TradeUnion_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_TradeUnion_delta_old";
        INSERT INTO "dbrdf_TradeUnion_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_TradeUnion_delta_new" t0;
        TRUNCATE TABLE "dbrdf_TradeUnion_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 318
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_timeInSpace_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_timeInSpace_delta_old1"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26800;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_timeInSpace_delta_old1" ON "dbrdf_timeInSpace_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_timeInSpace_delta_old1" ON "dbrdf_timeInSpace_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_timeInSpace_delta_new1"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26800, t0.o FROM "dbrdf_timeInSpace_delta_new1" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_timeInSpace_delta_old1";
        INSERT INTO "dbrdf_timeInSpace_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_timeInSpace_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_timeInSpace_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 319
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 320
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 321
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 322
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_height_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_height_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26804;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_height_delta_old0" ON "dbrdf_height_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_height_delta_old0" ON "dbrdf_height_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_height_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26804, t0.o FROM "dbrdf_height_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_height_delta_old0";
        INSERT INTO "dbrdf_height_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_height_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_height_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 323
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 324
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Mammal_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Mammal_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26806;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Mammal_delta_old" ON "dbrdf_Mammal_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Mammal_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Mammal$delta_new>(?Y) :- <http://dbpedia.org/ontology/Mammal$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Mammal_delta_new"(s) SELECT t1.o FROM "dbrdf_Mammal_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26806);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26806 FROM "dbrdf_Mammal_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Mammal_delta_old";
        INSERT INTO "dbrdf_Mammal_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Mammal_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Mammal_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 325
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 326
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 327
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 328
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 329
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 330
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 331
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 332
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 333
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationDensity_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_populationDensity_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26815;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_populationDensity_delta_old" ON "dbrdf_populationDensity_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_populationDensity_delta_old" ON "dbrdf_populationDensity_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationDensity_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26815, t0.o FROM "dbrdf_populationDensity_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_populationDensity_delta_old";
        INSERT INTO "dbrdf_populationDensity_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_populationDensity_delta_new" t0;
        TRUNCATE TABLE "dbrdf_populationDensity_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 334
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Fish_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Fish_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26816;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Fish_delta_old" ON "dbrdf_Fish_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Fish_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Fish$delta_new>(?Y) :- <http://dbpedia.org/ontology/Fish$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Fish_delta_new"(s) SELECT t1.o FROM "dbrdf_Fish_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26816);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26816 FROM "dbrdf_Fish_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Fish_delta_old";
        INSERT INTO "dbrdf_Fish_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Fish_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Fish_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 335
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 336
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26818, t0.o FROM "dbrdf_lunarOrbitTime_delta_new0" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_lunarOrbitTime_delta_old0";
        INSERT INTO "dbrdf_lunarOrbitTime_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lunarOrbitTime_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_lunarOrbitTime_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 337
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 338
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 339
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 340
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 341
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_PolishKing_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_PolishKing_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26823;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_PolishKing_delta_old" ON "dbrdf_PolishKing_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_PolishKing_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/PolishKing$delta_new>(?Y) :- <http://dbpedia.org/ontology/PolishKing$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_PolishKing_delta_new"(s) SELECT t1.o FROM "dbrdf_PolishKing_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26823);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26823 FROM "dbrdf_PolishKing_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_PolishKing_delta_old";
        INSERT INTO "dbrdf_PolishKing_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_PolishKing_delta_new" t0;
        TRUNCATE TABLE "dbrdf_PolishKing_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 342
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 343
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 344
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_BritishRoyalty_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_BritishRoyalty_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26826;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_BritishRoyalty_delta_old" ON "dbrdf_BritishRoyalty_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_BritishRoyalty_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/BritishRoyalty$delta_new>(?Y) :- <http://dbpedia.org/ontology/BritishRoyalty$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_BritishRoyalty_delta_new"(s) SELECT t1.o FROM "dbrdf_BritishRoyalty_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26826);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26826 FROM "dbrdf_BritishRoyalty_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_BritishRoyalty_delta_old";
        INSERT INTO "dbrdf_BritishRoyalty_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_BritishRoyalty_delta_new" t0;
        TRUNCATE TABLE "dbrdf_BritishRoyalty_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 345
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 346
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_SambaSchool_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SambaSchool_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26828;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SambaSchool_delta_old" ON "dbrdf_SambaSchool_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SambaSchool_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/SambaSchool$delta_new>(?Y) :- <http://dbpedia.org/ontology/SambaSchool$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_SambaSchool_delta_new"(s) SELECT t1.o FROM "dbrdf_SambaSchool_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26828);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26828 FROM "dbrdf_SambaSchool_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SambaSchool_delta_old";
        INSERT INTO "dbrdf_SambaSchool_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SambaSchool_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SambaSchool_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 347
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 348
    ---- DEPENDS ON: 347, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Ideology>(?X1) :- <http://dbpedia.org/ontology/ideology>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.o, 2, 26830 FROM "__triples" t0 WHERE t0.p = 26829 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.o AND ex.p = 2 AND ex.o = 26830);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Ideology_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Ideology_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26830;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Ideology_delta_old" ON "dbrdf_Ideology_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Ideology_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Ideology$delta_new>(?Y) :- <http://dbpedia.org/ontology/Ideology$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Ideology_delta_new"(s) SELECT t1.o FROM "dbrdf_Ideology_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26830);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26830 FROM "dbrdf_Ideology_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Ideology_delta_old";
        INSERT INTO "dbrdf_Ideology_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Ideology_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Ideology_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 349
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 350
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 351
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 352
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 353
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 354
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 355
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 356
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 357
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 358
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 359
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 360
    ---- DEPENDS ON: 236, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Theatre>(?X) :- <http://dbpedia.org/ontology/currentProduction>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26842 FROM "__triples" t0 WHERE t0.p = 26718 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26842);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Theatre_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Theatre_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26842;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Theatre_delta_old" ON "dbrdf_Theatre_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Theatre_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Theatre$delta_new>(?Y) :- <http://dbpedia.org/ontology/Theatre$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Theatre_delta_new"(s) SELECT t1.o FROM "dbrdf_Theatre_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26842);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26842 FROM "dbrdf_Theatre_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Theatre_delta_old";
        INSERT INTO "dbrdf_Theatre_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Theatre_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Theatre_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 361
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_chairperson_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_chairperson_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26843;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_chairperson_delta_old" ON "dbrdf_chairperson_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_chairperson_delta_old" ON "dbrdf_chairperson_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_chairperson_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/chairperson$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/chairperson$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_chairperson_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_chairperson_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26843 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/chairperson$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/chairperson$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_chairperson_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_chairperson_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26843 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26843, t0.o FROM "dbrdf_chairperson_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_chairperson_delta_old";
        INSERT INTO "dbrdf_chairperson_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_chairperson_delta_new" t0;
        TRUNCATE TABLE "dbrdf_chairperson_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 362
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_fuelType_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_fuelType_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26844;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_fuelType_delta_old" ON "dbrdf_fuelType_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_fuelType_delta_old" ON "dbrdf_fuelType_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_fuelType_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/fuelType$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/fuelType$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_fuelType_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_fuelType_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26844 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/fuelType$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/fuelType$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_fuelType_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_fuelType_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26844 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26844, t0.o FROM "dbrdf_fuelType_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_fuelType_delta_old";
        INSERT INTO "dbrdf_fuelType_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_fuelType_delta_new" t0;
        TRUNCATE TABLE "dbrdf_fuelType_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 363
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sisterCollege_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sisterCollege_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26845;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sisterCollege_delta_old" ON "dbrdf_sisterCollege_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sisterCollege_delta_old" ON "dbrdf_sisterCollege_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sisterCollege_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/sisterCollege$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/sisterCollege$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_sisterCollege_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_sisterCollege_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26845 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/sisterCollege$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/sisterCollege$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_sisterCollege_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_sisterCollege_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26845 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26845, t0.o FROM "dbrdf_sisterCollege_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_sisterCollege_delta_old";
        INSERT INTO "dbrdf_sisterCollege_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_sisterCollege_delta_new" t0;
        TRUNCATE TABLE "dbrdf_sisterCollege_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 364
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumDischarge_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_maximumDischarge_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26846;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_maximumDischarge_delta_old0" ON "dbrdf_maximumDischarge_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_maximumDischarge_delta_old0" ON "dbrdf_maximumDischarge_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumDischarge_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/Stream/maximumDischarge$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Stream/maximumDischarge$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_maximumDischarge_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_maximumDischarge_delta_old0" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26846 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/Stream/maximumDischarge$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/Stream/maximumDischarge$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_maximumDischarge_delta_new0"(s, o) SELECT t0.s, t1.o FROM "dbrdf_maximumDischarge_delta_old0" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26846 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26846, t0.o FROM "dbrdf_maximumDischarge_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_maximumDischarge_delta_old0";
        INSERT INTO "dbrdf_maximumDischarge_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_maximumDischarge_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_maximumDischarge_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 365
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_product_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_product_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26847;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_product_delta_old" ON "dbrdf_product_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_product_delta_old" ON "dbrdf_product_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_product_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/product$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/product$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_product_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_product_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26847 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/product$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/product$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_product_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_product_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26847 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26847, t0.o FROM "dbrdf_product_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_product_delta_old";
        INSERT INTO "dbrdf_product_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_product_delta_new" t0;
        TRUNCATE TABLE "dbrdf_product_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 366
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_leader_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_leader_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26848;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_leader_delta_old" ON "dbrdf_leader_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_leader_delta_old" ON "dbrdf_leader_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_leader_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/leader$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/leader$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_leader_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_leader_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26848 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/leader$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/leader$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_leader_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_leader_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26848 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26848, t0.o FROM "dbrdf_leader_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_leader_delta_old";
        INSERT INTO "dbrdf_leader_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_leader_delta_new" t0;
        TRUNCATE TABLE "dbrdf_leader_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 367
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_electionDateLeader_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_electionDateLeader_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26849;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_electionDateLeader_delta_old" ON "dbrdf_electionDateLeader_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_electionDateLeader_delta_old" ON "dbrdf_electionDateLeader_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_electionDateLeader_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/electionDateLeader$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/electionDateLeader$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_electionDateLeader_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_electionDateLeader_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26849 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/electionDateLeader$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/electionDateLeader$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_electionDateLeader_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_electionDateLeader_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26849 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26849, t0.o FROM "dbrdf_electionDateLeader_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_electionDateLeader_delta_old";
        INSERT INTO "dbrdf_electionDateLeader_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_electionDateLeader_delta_new" t0;
        TRUNCATE TABLE "dbrdf_electionDateLeader_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 368
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_President_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_President_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26850;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_President_delta_old" ON "dbrdf_President_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_President_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/President$delta_new>(?Y) :- <http://dbpedia.org/ontology/President$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_President_delta_new"(s) SELECT t1.o FROM "dbrdf_President_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26850);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26850 FROM "dbrdf_President_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_President_delta_old";
        INSERT INTO "dbrdf_President_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_President_delta_new" t0;
        TRUNCATE TABLE "dbrdf_President_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 369
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_astrologicalSign_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_astrologicalSign_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26851;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_astrologicalSign_delta_old" ON "dbrdf_astrologicalSign_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_astrologicalSign_delta_old" ON "dbrdf_astrologicalSign_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_astrologicalSign_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/astrologicalSign$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/astrologicalSign$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_astrologicalSign_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_astrologicalSign_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26851 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/astrologicalSign$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/astrologicalSign$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_astrologicalSign_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_astrologicalSign_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26851 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26851, t0.o FROM "dbrdf_astrologicalSign_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_astrologicalSign_delta_old";
        INSERT INTO "dbrdf_astrologicalSign_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_astrologicalSign_delta_new" t0;
        TRUNCATE TABLE "dbrdf_astrologicalSign_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 370
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_minorityLeader_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_minorityLeader_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26852;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_minorityLeader_delta_old" ON "dbrdf_minorityLeader_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_minorityLeader_delta_old" ON "dbrdf_minorityLeader_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_minorityLeader_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/minorityLeader$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/minorityLeader$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_minorityLeader_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_minorityLeader_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26852 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/minorityLeader$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/minorityLeader$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_minorityLeader_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_minorityLeader_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26852 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26852, t0.o FROM "dbrdf_minorityLeader_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_minorityLeader_delta_old";
        INSERT INTO "dbrdf_minorityLeader_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_minorityLeader_delta_new" t0;
        TRUNCATE TABLE "dbrdf_minorityLeader_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 371
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_foundingDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_foundingDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26853;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_foundingDate_delta_old" ON "dbrdf_foundingDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_foundingDate_delta_old" ON "dbrdf_foundingDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_foundingDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/foundingDate$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/foundingDate$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_foundingDate_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_foundingDate_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26853 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/foundingDate$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/foundingDate$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_foundingDate_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_foundingDate_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26853 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26853, t0.o FROM "dbrdf_foundingDate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_foundingDate_delta_old";
        INSERT INTO "dbrdf_foundingDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_foundingDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_foundingDate_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 372
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_vicePrincipalLabel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_vicePrincipalLabel_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26854;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_vicePrincipalLabel_delta_old" ON "dbrdf_vicePrincipalLabel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_vicePrincipalLabel_delta_old" ON "dbrdf_vicePrincipalLabel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_vicePrincipalLabel_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/vicePrincipalLabel$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/vicePrincipalLabel$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_vicePrincipalLabel_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_vicePrincipalLabel_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26854 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/vicePrincipalLabel$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/vicePrincipalLabel$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_vicePrincipalLabel_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_vicePrincipalLabel_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26854 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26854, t0.o FROM "dbrdf_vicePrincipalLabel_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_vicePrincipalLabel_delta_old";
        INSERT INTO "dbrdf_vicePrincipalLabel_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_vicePrincipalLabel_delta_new" t0;
        TRUNCATE TABLE "dbrdf_vicePrincipalLabel_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 373
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ibdbId_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ibdbId_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26855;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ibdbId_delta_old" ON "dbrdf_ibdbId_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ibdbId_delta_old" ON "dbrdf_ibdbId_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ibdbId_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/ibdbId$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/ibdbId$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_ibdbId_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_ibdbId_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26855 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/ibdbId$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/ibdbId$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_ibdbId_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_ibdbId_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26855 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26855, t0.o FROM "dbrdf_ibdbId_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_ibdbId_delta_old";
        INSERT INTO "dbrdf_ibdbId_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_ibdbId_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ibdbId_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 374
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Cyclist_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Cyclist_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26856;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Cyclist_delta_old" ON "dbrdf_Cyclist_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Cyclist_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/Cyclist$delta_new>(?Y) :- <http://dbpedia.org/ontology/Cyclist$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Cyclist_delta_new"(s) SELECT t1.o FROM "dbrdf_Cyclist_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26856);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26856 FROM "dbrdf_Cyclist_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Cyclist_delta_old";
        INSERT INTO "dbrdf_Cyclist_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Cyclist_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Cyclist_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 375
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_graySubject_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_graySubject_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26857;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_graySubject_delta_old" ON "dbrdf_graySubject_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_graySubject_delta_old" ON "dbrdf_graySubject_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_graySubject_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/graySubject$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/graySubject$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_graySubject_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_graySubject_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26857 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/graySubject$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/graySubject$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_graySubject_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_graySubject_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26857 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26857, t0.o FROM "dbrdf_graySubject_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_graySubject_delta_old";
        INSERT INTO "dbrdf_graySubject_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_graySubject_delta_new" t0;
        TRUNCATE TABLE "dbrdf_graySubject_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 376
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_campusType_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_campusType_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26858;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_campusType_delta_old" ON "dbrdf_campusType_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_campusType_delta_old" ON "dbrdf_campusType_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_campusType_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/campusType$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/campusType$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_campusType_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_campusType_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26858 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/campusType$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/campusType$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_campusType_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_campusType_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26858 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26858, t0.o FROM "dbrdf_campusType_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_campusType_delta_old";
        INSERT INTO "dbrdf_campusType_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_campusType_delta_new" t0;
        TRUNCATE TABLE "dbrdf_campusType_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 377
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_bodyStyle_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_bodyStyle_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26859;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_bodyStyle_delta_old" ON "dbrdf_bodyStyle_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_bodyStyle_delta_old" ON "dbrdf_bodyStyle_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_bodyStyle_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/bodyStyle$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/bodyStyle$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_bodyStyle_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_bodyStyle_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26859 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/bodyStyle$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/bodyStyle$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_bodyStyle_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_bodyStyle_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26859 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26859, t0.o FROM "dbrdf_bodyStyle_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_bodyStyle_delta_old";
        INSERT INTO "dbrdf_bodyStyle_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_bodyStyle_delta_new" t0;
        TRUNCATE TABLE "dbrdf_bodyStyle_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 378
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_starRating_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_starRating_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26860;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_starRating_delta_old" ON "dbrdf_starRating_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_starRating_delta_old" ON "dbrdf_starRating_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_starRating_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/starRating$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/starRating$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_starRating_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_starRating_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26860 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/starRating$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/starRating$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_starRating_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_starRating_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26860 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26860, t0.o FROM "dbrdf_starRating_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_starRating_delta_old";
        INSERT INTO "dbrdf_starRating_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_starRating_delta_new" t0;
        TRUNCATE TABLE "dbrdf_starRating_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 379
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfPostgraduateStudents_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfPostgraduateStudents_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26861;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfPostgraduateStudents_delta_old" ON "dbrdf_numberOfPostgraduateStudents_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfPostgraduateStudents_delta_old" ON "dbrdf_numberOfPostgraduateStudents_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfPostgraduateStudents_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/numberOfPostgraduateStudents$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/numberOfPostgraduateStudents$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_numberOfPostgraduateStudents_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_numberOfPostgraduateStudents_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26861 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/numberOfPostgraduateStudents$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/numberOfPostgraduateStudents$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_numberOfPostgraduateStudents_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_numberOfPostgraduateStudents_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26861 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26861, t0.o FROM "dbrdf_numberOfPostgraduateStudents_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_numberOfPostgraduateStudents_delta_old";
        INSERT INTO "dbrdf_numberOfPostgraduateStudents_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfPostgraduateStudents_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfPostgraduateStudents_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 380
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_uniprot_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_uniprot_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26862;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_uniprot_delta_old" ON "dbrdf_uniprot_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_uniprot_delta_old" ON "dbrdf_uniprot_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_uniprot_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/uniprot$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/uniprot$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_uniprot_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_uniprot_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26862 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/uniprot$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/uniprot$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_uniprot_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_uniprot_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26862 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26862, t0.o FROM "dbrdf_uniprot_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_uniprot_delta_old";
        INSERT INTO "dbrdf_uniprot_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_uniprot_delta_new" t0;
        TRUNCATE TABLE "dbrdf_uniprot_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 381
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lunarSurfaceTime_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lunarSurfaceTime_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26863;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lunarSurfaceTime_delta_old" ON "dbrdf_lunarSurfaceTime_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lunarSurfaceTime_delta_old" ON "dbrdf_lunarSurfaceTime_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lunarSurfaceTime_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/SpaceMission/lunarSurfaceTime$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/SpaceMission/lunarSurfaceTime$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_lunarSurfaceTime_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_lunarSurfaceTime_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26863 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/SpaceMission/lunarSurfaceTime$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/SpaceMission/lunarSurfaceTime$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_lunarSurfaceTime_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_lunarSurfaceTime_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26863 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26863, t0.o FROM "dbrdf_lunarSurfaceTime_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_lunarSurfaceTime_delta_old";
        INSERT INTO "dbrdf_lunarSurfaceTime_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lunarSurfaceTime_delta_new" t0;
        TRUNCATE TABLE "dbrdf_lunarSurfaceTime_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 382
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mouthDistrict_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mouthDistrict_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26864;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mouthDistrict_delta_old" ON "dbrdf_mouthDistrict_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mouthDistrict_delta_old" ON "dbrdf_mouthDistrict_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mouthDistrict_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/mouthDistrict$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/mouthDistrict$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_mouthDistrict_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_mouthDistrict_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26864 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/mouthDistrict$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/mouthDistrict$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_mouthDistrict_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_mouthDistrict_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26864 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26864, t0.o FROM "dbrdf_mouthDistrict_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_mouthDistrict_delta_old";
        INSERT INTO "dbrdf_mouthDistrict_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_mouthDistrict_delta_new" t0;
        TRUNCATE TABLE "dbrdf_mouthDistrict_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 383
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_years_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_years_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26865;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_years_delta_old" ON "dbrdf_years_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_years_delta_old" ON "dbrdf_years_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_years_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/years$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/years$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_years_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_years_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26865 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/years$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/years$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_years_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_years_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26865 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26865, t0.o FROM "dbrdf_years_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_years_delta_old";
        INSERT INTO "dbrdf_years_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_years_delta_new" t0;
        TRUNCATE TABLE "dbrdf_years_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 384
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_BadmintonPlayer_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_BadmintonPlayer_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26866;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_BadmintonPlayer_delta_old" ON "dbrdf_BadmintonPlayer_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_BadmintonPlayer_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/BadmintonPlayer$delta_new>(?Y) :- <http://dbpedia.org/ontology/BadmintonPlayer$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_BadmintonPlayer_delta_new"(s) SELECT t1.o FROM "dbrdf_BadmintonPlayer_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26866);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26866 FROM "dbrdf_BadmintonPlayer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_BadmintonPlayer_delta_old";
        INSERT INTO "dbrdf_BadmintonPlayer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_BadmintonPlayer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_BadmintonPlayer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 385
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_refseqprotein_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_refseqprotein_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26867;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_refseqprotein_delta_old" ON "dbrdf_refseqprotein_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_refseqprotein_delta_old" ON "dbrdf_refseqprotein_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_refseqprotein_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/refseqprotein$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/refseqprotein$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_refseqprotein_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_refseqprotein_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26867 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/refseqprotein$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/refseqprotein$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_refseqprotein_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_refseqprotein_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26867 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26867, t0.o FROM "dbrdf_refseqprotein_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_refseqprotein_delta_old";
        INSERT INTO "dbrdf_refseqprotein_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_refseqprotein_delta_new" t0;
        TRUNCATE TABLE "dbrdf_refseqprotein_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 386
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceConfluenceMountain_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sourceConfluenceMountain_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26868;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sourceConfluenceMountain_delta_old" ON "dbrdf_sourceConfluenceMountain_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sourceConfluenceMountain_delta_old" ON "dbrdf_sourceConfluenceMountain_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceConfluenceMountain_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/sourceConfluenceMountain$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/sourceConfluenceMountain$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_sourceConfluenceMountain_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_sourceConfluenceMountain_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26868 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/sourceConfluenceMountain$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/sourceConfluenceMountain$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_sourceConfluenceMountain_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_sourceConfluenceMountain_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26868 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26868, t0.o FROM "dbrdf_sourceConfluenceMountain_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_sourceConfluenceMountain_delta_old";
        INSERT INTO "dbrdf_sourceConfluenceMountain_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_sourceConfluenceMountain_delta_new" t0;
        TRUNCATE TABLE "dbrdf_sourceConfluenceMountain_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 387
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_beltwayCity_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_beltwayCity_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26869;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_beltwayCity_delta_old" ON "dbrdf_beltwayCity_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_beltwayCity_delta_old" ON "dbrdf_beltwayCity_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_beltwayCity_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/beltwayCity$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/beltwayCity$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_beltwayCity_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_beltwayCity_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26869 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/beltwayCity$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/beltwayCity$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_beltwayCity_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_beltwayCity_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26869 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26869, t0.o FROM "dbrdf_beltwayCity_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_beltwayCity_delta_old";
        INSERT INTO "dbrdf_beltwayCity_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_beltwayCity_delta_new" t0;
        TRUNCATE TABLE "dbrdf_beltwayCity_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 388
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_strength_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_strength_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26870;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_strength_delta_old" ON "dbrdf_strength_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_strength_delta_old" ON "dbrdf_strength_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_strength_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/strength$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/strength$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_strength_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_strength_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26870 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/strength$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/strength$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_strength_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_strength_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26870 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26870, t0.o FROM "dbrdf_strength_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_strength_delta_old";
        INSERT INTO "dbrdf_strength_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_strength_delta_new" t0;
        TRUNCATE TABLE "dbrdf_strength_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 389
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_christeningDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_christeningDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26871;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_christeningDate_delta_old" ON "dbrdf_christeningDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_christeningDate_delta_old" ON "dbrdf_christeningDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_christeningDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/christeningDate$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/christeningDate$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_christeningDate_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_christeningDate_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26871 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/christeningDate$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/christeningDate$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_christeningDate_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_christeningDate_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26871 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26871, t0.o FROM "dbrdf_christeningDate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_christeningDate_delta_old";
        INSERT INTO "dbrdf_christeningDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_christeningDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_christeningDate_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 390
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_debutTeam_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_debutTeam_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26872;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_debutTeam_delta_old" ON "dbrdf_debutTeam_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_debutTeam_delta_old" ON "dbrdf_debutTeam_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_debutTeam_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/debutTeam$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/debutTeam$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_debutTeam_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_debutTeam_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26872 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/debutTeam$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/debutTeam$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_debutTeam_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_debutTeam_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26872 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26872, t0.o FROM "dbrdf_debutTeam_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_debutTeam_delta_old";
        INSERT INTO "dbrdf_debutTeam_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_debutTeam_delta_new" t0;
        TRUNCATE TABLE "dbrdf_debutTeam_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 391
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_criteria_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_criteria_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26873;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_criteria_delta_old" ON "dbrdf_criteria_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_criteria_delta_old" ON "dbrdf_criteria_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_criteria_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/criteria$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/criteria$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_criteria_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_criteria_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26873 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/criteria$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/criteria$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_criteria_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_criteria_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26873 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26873, t0.o FROM "dbrdf_criteria_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_criteria_delta_old";
        INSERT INTO "dbrdf_criteria_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_criteria_delta_new" t0;
        TRUNCATE TABLE "dbrdf_criteria_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 392
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_languageCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_languageCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26874;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_languageCode_delta_old" ON "dbrdf_languageCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_languageCode_delta_old" ON "dbrdf_languageCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_languageCode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/languageCode$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/languageCode$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_languageCode_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_languageCode_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26874 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/languageCode$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/languageCode$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_languageCode_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_languageCode_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26874 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26874, t0.o FROM "dbrdf_languageCode_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_languageCode_delta_old";
        INSERT INTO "dbrdf_languageCode_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_languageCode_delta_new" t0;
        TRUNCATE TABLE "dbrdf_languageCode_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 393
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_origin_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_origin_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26875;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_origin_delta_old" ON "dbrdf_origin_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_origin_delta_old" ON "dbrdf_origin_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_origin_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/origin$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/origin$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_origin_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_origin_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26875 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/origin$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/origin$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_origin_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_origin_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26875 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26875, t0.o FROM "dbrdf_origin_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_origin_delta_old";
        INSERT INTO "dbrdf_origin_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_origin_delta_new" t0;
        TRUNCATE TABLE "dbrdf_origin_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 394
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_weight_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_weight_delta_old1"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26876;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_weight_delta_old1" ON "dbrdf_weight_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_weight_delta_old1" ON "dbrdf_weight_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_weight_delta_new1"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/MeanOfTransportation/weight$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/MeanOfTransportation/weight$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_weight_delta_new1"(s, o) SELECT t1.o, t0.o FROM "dbrdf_weight_delta_old1" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26876 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/MeanOfTransportation/weight$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/MeanOfTransportation/weight$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_weight_delta_new1"(s, o) SELECT t0.s, t1.o FROM "dbrdf_weight_delta_old1" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26876 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26876, t0.o FROM "dbrdf_weight_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_weight_delta_old1";
        INSERT INTO "dbrdf_weight_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_weight_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_weight_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 395
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_missions_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_missions_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26877;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_missions_delta_old" ON "dbrdf_missions_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_missions_delta_old" ON "dbrdf_missions_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_missions_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/missions$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/missions$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_missions_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_missions_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26877 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/missions$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/missions$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_missions_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_missions_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26877 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26877, t0.o FROM "dbrdf_missions_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_missions_delta_old";
        INSERT INTO "dbrdf_missions_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_missions_delta_new" t0;
        TRUNCATE TABLE "dbrdf_missions_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 396
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastPosition_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lastPosition_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26878;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lastPosition_delta_old" ON "dbrdf_lastPosition_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lastPosition_delta_old" ON "dbrdf_lastPosition_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastPosition_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/lastPosition$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/lastPosition$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_lastPosition_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_lastPosition_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26878 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/lastPosition$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/lastPosition$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_lastPosition_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_lastPosition_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26878 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26878, t0.o FROM "dbrdf_lastPosition_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_lastPosition_delta_old";
        INSERT INTO "dbrdf_lastPosition_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lastPosition_delta_new" t0;
        TRUNCATE TABLE "dbrdf_lastPosition_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 397
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_commune_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_commune_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26879;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_commune_delta_old" ON "dbrdf_commune_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_commune_delta_old" ON "dbrdf_commune_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_commune_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/commune$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/commune$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_commune_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_commune_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26879 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/commune$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/commune$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_commune_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_commune_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26879 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26879, t0.o FROM "dbrdf_commune_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_commune_delta_old";
        INSERT INTO "dbrdf_commune_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_commune_delta_new" t0;
        TRUNCATE TABLE "dbrdf_commune_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 398
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_iso6391Code_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_iso6391Code_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26880;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_iso6391Code_delta_old" ON "dbrdf_iso6391Code_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_iso6391Code_delta_old" ON "dbrdf_iso6391Code_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_iso6391Code_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/iso6391Code$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/iso6391Code$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_iso6391Code_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_iso6391Code_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26880 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/iso6391Code$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/iso6391Code$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_iso6391Code_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_iso6391Code_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26880 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26880, t0.o FROM "dbrdf_iso6391Code_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_iso6391Code_delta_old";
        INSERT INTO "dbrdf_iso6391Code_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_iso6391Code_delta_new" t0;
        TRUNCATE TABLE "dbrdf_iso6391Code_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 399
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_routeJunction_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_routeJunction_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26881;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_routeJunction_delta_old" ON "dbrdf_routeJunction_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_routeJunction_delta_old" ON "dbrdf_routeJunction_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_routeJunction_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/routeJunction$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/routeJunction$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_routeJunction_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_routeJunction_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26881 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/routeJunction$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/routeJunction$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_routeJunction_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_routeJunction_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26881 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26881, t0.o FROM "dbrdf_routeJunction_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_routeJunction_delta_old";
        INSERT INTO "dbrdf_routeJunction_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_routeJunction_delta_new" t0;
        TRUNCATE TABLE "dbrdf_routeJunction_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 400
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_restingPlacePosition_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_restingPlacePosition_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26882;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_restingPlacePosition_delta_old" ON "dbrdf_restingPlacePosition_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_restingPlacePosition_delta_old" ON "dbrdf_restingPlacePosition_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_restingPlacePosition_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/restingPlacePosition$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/restingPlacePosition$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_restingPlacePosition_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_restingPlacePosition_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26882 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/restingPlacePosition$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/restingPlacePosition$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_restingPlacePosition_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_restingPlacePosition_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26882 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26882, t0.o FROM "dbrdf_restingPlacePosition_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_restingPlacePosition_delta_old";
        INSERT INTO "dbrdf_restingPlacePosition_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_restingPlacePosition_delta_new" t0;
        TRUNCATE TABLE "dbrdf_restingPlacePosition_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 401
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtOtherTournaments_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtOtherTournaments_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26883;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtOtherTournaments_delta_old" ON "dbrdf_winsAtOtherTournaments_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtOtherTournaments_delta_old" ON "dbrdf_winsAtOtherTournaments_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtOtherTournaments_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/winsAtOtherTournaments$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/winsAtOtherTournaments$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_winsAtOtherTournaments_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_winsAtOtherTournaments_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26883 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/winsAtOtherTournaments$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/winsAtOtherTournaments$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_winsAtOtherTournaments_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_winsAtOtherTournaments_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26883 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26883, t0.o FROM "dbrdf_winsAtOtherTournaments_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_winsAtOtherTournaments_delta_old";
        INSERT INTO "dbrdf_winsAtOtherTournaments_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_winsAtOtherTournaments_delta_new" t0;
        TRUNCATE TABLE "dbrdf_winsAtOtherTournaments_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 402
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dateCompleted_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dateCompleted_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26884;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dateCompleted_delta_old" ON "dbrdf_dateCompleted_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dateCompleted_delta_old" ON "dbrdf_dateCompleted_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dateCompleted_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/dateCompleted$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/dateCompleted$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_dateCompleted_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_dateCompleted_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26884 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/dateCompleted$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/dateCompleted$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_dateCompleted_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_dateCompleted_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26884 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26884, t0.o FROM "dbrdf_dateCompleted_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_dateCompleted_delta_old";
        INSERT INTO "dbrdf_dateCompleted_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_dateCompleted_delta_new" t0;
        TRUNCATE TABLE "dbrdf_dateCompleted_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 403
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_subdivisions_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_subdivisions_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26885;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_subdivisions_delta_old" ON "dbrdf_subdivisions_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_subdivisions_delta_old" ON "dbrdf_subdivisions_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_subdivisions_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/subdivisions$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/subdivisions$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_subdivisions_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_subdivisions_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26885 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/subdivisions$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/subdivisions$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_subdivisions_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_subdivisions_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26885 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26885, t0.o FROM "dbrdf_subdivisions_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_subdivisions_delta_old";
        INSERT INTO "dbrdf_subdivisions_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_subdivisions_delta_new" t0;
        TRUNCATE TABLE "dbrdf_subdivisions_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 404
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_deathPlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_deathPlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26886;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_deathPlace_delta_old" ON "dbrdf_deathPlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_deathPlace_delta_old" ON "dbrdf_deathPlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_deathPlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/deathPlace$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/deathPlace$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_deathPlace_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_deathPlace_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26886 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/deathPlace$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/deathPlace$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_deathPlace_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_deathPlace_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26886 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26886, t0.o FROM "dbrdf_deathPlace_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_deathPlace_delta_old";
        INSERT INTO "dbrdf_deathPlace_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_deathPlace_delta_new" t0;
        TRUNCATE TABLE "dbrdf_deathPlace_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 405
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_visitorsTotal_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_visitorsTotal_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26887;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_visitorsTotal_delta_old" ON "dbrdf_visitorsTotal_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_visitorsTotal_delta_old" ON "dbrdf_visitorsTotal_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_visitorsTotal_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/visitorsTotal$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/visitorsTotal$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_visitorsTotal_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_visitorsTotal_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26887 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/visitorsTotal$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/visitorsTotal$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_visitorsTotal_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_visitorsTotal_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26887 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26887, t0.o FROM "dbrdf_visitorsTotal_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_visitorsTotal_delta_old";
        INSERT INTO "dbrdf_visitorsTotal_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_visitorsTotal_delta_new" t0;
        TRUNCATE TABLE "dbrdf_visitorsTotal_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 406
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_notes_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_notes_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26888;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_notes_delta_old" ON "dbrdf_notes_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_notes_delta_old" ON "dbrdf_notes_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_notes_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/notes$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/notes$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_notes_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_notes_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26888 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/notes$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/notes$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_notes_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_notes_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26888 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26888, t0.o FROM "dbrdf_notes_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_notes_delta_old";
        INSERT INTO "dbrdf_notes_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_notes_delta_new" t0;
        TRUNCATE TABLE "dbrdf_notes_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 407
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_trustee_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_trustee_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26889;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_trustee_delta_old" ON "dbrdf_trustee_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_trustee_delta_old" ON "dbrdf_trustee_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_trustee_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/trustee$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/trustee$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_trustee_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_trustee_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26889 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/trustee$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/trustee$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_trustee_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_trustee_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26889 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26889, t0.o FROM "dbrdf_trustee_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_trustee_delta_old";
        INSERT INTO "dbrdf_trustee_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_trustee_delta_new" t0;
        TRUNCATE TABLE "dbrdf_trustee_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 408
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_internationally_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_internationally_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26890;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_internationally_delta_old" ON "dbrdf_internationally_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_internationally_delta_old" ON "dbrdf_internationally_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_internationally_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/internationally$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/internationally$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_internationally_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_internationally_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26890 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/internationally$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/internationally$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_internationally_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_internationally_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26890 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26890, t0.o FROM "dbrdf_internationally_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_internationally_delta_old";
        INSERT INTO "dbrdf_internationally_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_internationally_delta_new" t0;
        TRUNCATE TABLE "dbrdf_internationally_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 409
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_eTeatrId_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_eTeatrId_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26891;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_eTeatrId_delta_old" ON "dbrdf_eTeatrId_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_eTeatrId_delta_old" ON "dbrdf_eTeatrId_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_eTeatrId_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/eTeatrId$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/eTeatrId$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_eTeatrId_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_eTeatrId_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26891 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/eTeatrId$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/eTeatrId$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_eTeatrId_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_eTeatrId_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26891 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26891, t0.o FROM "dbrdf_eTeatrId_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_eTeatrId_delta_old";
        INSERT INTO "dbrdf_eTeatrId_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_eTeatrId_delta_new" t0;
        TRUNCATE TABLE "dbrdf_eTeatrId_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 410
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rankingsSingles_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rankingsSingles_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26892;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rankingsSingles_delta_old" ON "dbrdf_rankingsSingles_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rankingsSingles_delta_old" ON "dbrdf_rankingsSingles_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rankingsSingles_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/rankingsSingles$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/rankingsSingles$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_rankingsSingles_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_rankingsSingles_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26892 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/rankingsSingles$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/rankingsSingles$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_rankingsSingles_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_rankingsSingles_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26892 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26892, t0.o FROM "dbrdf_rankingsSingles_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_rankingsSingles_delta_old";
        INSERT INTO "dbrdf_rankingsSingles_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_rankingsSingles_delta_new" t0;
        TRUNCATE TABLE "dbrdf_rankingsSingles_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 411
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_retired_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_retired_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26893;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_retired_delta_old" ON "dbrdf_retired_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_retired_delta_old" ON "dbrdf_retired_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_retired_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/retired$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/retired$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_retired_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_retired_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26893 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/retired$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/retired$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_retired_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_retired_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26893 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26893, t0.o FROM "dbrdf_retired_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_retired_delta_old";
        INSERT INTO "dbrdf_retired_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_retired_delta_new" t0;
        TRUNCATE TABLE "dbrdf_retired_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 412
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfVolunteers_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfVolunteers_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26894;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfVolunteers_delta_old" ON "dbrdf_numberOfVolunteers_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfVolunteers_delta_old" ON "dbrdf_numberOfVolunteers_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfVolunteers_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/numberOfVolunteers$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/numberOfVolunteers$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_numberOfVolunteers_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_numberOfVolunteers_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26894 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/numberOfVolunteers$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/numberOfVolunteers$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_numberOfVolunteers_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_numberOfVolunteers_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26894 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26894, t0.o FROM "dbrdf_numberOfVolunteers_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_numberOfVolunteers_delta_old";
        INSERT INTO "dbrdf_numberOfVolunteers_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfVolunteers_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfVolunteers_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 413
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_supplementalDraftRound_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_supplementalDraftRound_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26895;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_supplementalDraftRound_delta_old" ON "dbrdf_supplementalDraftRound_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_supplementalDraftRound_delta_old" ON "dbrdf_supplementalDraftRound_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_supplementalDraftRound_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/supplementalDraftRound$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/supplementalDraftRound$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_supplementalDraftRound_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_supplementalDraftRound_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26895 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/supplementalDraftRound$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/supplementalDraftRound$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_supplementalDraftRound_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_supplementalDraftRound_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26895 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26895, t0.o FROM "dbrdf_supplementalDraftRound_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_supplementalDraftRound_delta_old";
        INSERT INTO "dbrdf_supplementalDraftRound_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_supplementalDraftRound_delta_new" t0;
        TRUNCATE TABLE "dbrdf_supplementalDraftRound_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 414
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_casNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_casNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26896;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_casNumber_delta_old" ON "dbrdf_casNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_casNumber_delta_old" ON "dbrdf_casNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_casNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/casNumber$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/casNumber$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_casNumber_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_casNumber_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26896 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/casNumber$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/casNumber$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_casNumber_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_casNumber_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26896 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26896, t0.o FROM "dbrdf_casNumber_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_casNumber_delta_old";
        INSERT INTO "dbrdf_casNumber_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_casNumber_delta_new" t0;
        TRUNCATE TABLE "dbrdf_casNumber_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 415
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_crew_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_crew_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26897;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_crew_delta_old" ON "dbrdf_crew_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_crew_delta_old" ON "dbrdf_crew_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_crew_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/crew$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/crew$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_crew_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_crew_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26897 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/crew$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/crew$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_crew_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_crew_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26897 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26897, t0.o FROM "dbrdf_crew_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_crew_delta_old";
        INSERT INTO "dbrdf_crew_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_crew_delta_new" t0;
        TRUNCATE TABLE "dbrdf_crew_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 416
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_developer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_developer_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26898;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_developer_delta_old" ON "dbrdf_developer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_developer_delta_old" ON "dbrdf_developer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_developer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/developer$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/developer$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_developer_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_developer_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26898 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/developer$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/developer$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_developer_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_developer_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26898 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26898, t0.o FROM "dbrdf_developer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_developer_delta_old";
        INSERT INTO "dbrdf_developer_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_developer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_developer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 417
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Bird_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Bird_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26899;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Bird_delta_old" ON "dbrdf_Bird_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Bird_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/Bird$delta_new>(?Y) :- <http://dbpedia.org/ontology/Bird$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Bird_delta_new"(s) SELECT t1.o FROM "dbrdf_Bird_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26899);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26899 FROM "dbrdf_Bird_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Bird_delta_old";
        INSERT INTO "dbrdf_Bird_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Bird_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Bird_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 418
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_iobdbId_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_iobdbId_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26900;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_iobdbId_delta_old" ON "dbrdf_iobdbId_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_iobdbId_delta_old" ON "dbrdf_iobdbId_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_iobdbId_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/iobdbId$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/iobdbId$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_iobdbId_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_iobdbId_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26900 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/iobdbId$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/iobdbId$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_iobdbId_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_iobdbId_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26900 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26900, t0.o FROM "dbrdf_iobdbId_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_iobdbId_delta_old";
        INSERT INTO "dbrdf_iobdbId_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_iobdbId_delta_new" t0;
        TRUNCATE TABLE "dbrdf_iobdbId_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 419
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_place_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_place_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26901;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_place_delta_old" ON "dbrdf_place_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_place_delta_old" ON "dbrdf_place_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_place_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/place$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/place$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_place_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_place_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26901 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/place$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/place$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_place_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_place_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26901 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26901, t0.o FROM "dbrdf_place_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_place_delta_old";
        INSERT INTO "dbrdf_place_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_place_delta_new" t0;
        TRUNCATE TABLE "dbrdf_place_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 420
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_averageSpeed_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_averageSpeed_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26902;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_averageSpeed_delta_old0" ON "dbrdf_averageSpeed_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_averageSpeed_delta_old0" ON "dbrdf_averageSpeed_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_averageSpeed_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/Planet/averageSpeed$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Planet/averageSpeed$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_averageSpeed_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_averageSpeed_delta_old0" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26902 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/Planet/averageSpeed$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/Planet/averageSpeed$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_averageSpeed_delta_new0"(s, o) SELECT t0.s, t1.o FROM "dbrdf_averageSpeed_delta_old0" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26902 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26902, t0.o FROM "dbrdf_averageSpeed_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_averageSpeed_delta_old0";
        INSERT INTO "dbrdf_averageSpeed_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_averageSpeed_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_averageSpeed_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 421
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtNWIDE_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtNWIDE_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26903;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtNWIDE_delta_old" ON "dbrdf_winsAtNWIDE_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtNWIDE_delta_old" ON "dbrdf_winsAtNWIDE_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtNWIDE_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/winsAtNWIDE$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/winsAtNWIDE$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_winsAtNWIDE_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_winsAtNWIDE_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26903 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/winsAtNWIDE$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/winsAtNWIDE$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_winsAtNWIDE_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_winsAtNWIDE_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26903 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26903, t0.o FROM "dbrdf_winsAtNWIDE_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_winsAtNWIDE_delta_old";
        INSERT INTO "dbrdf_winsAtNWIDE_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_winsAtNWIDE_delta_new" t0;
        TRUNCATE TABLE "dbrdf_winsAtNWIDE_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 422
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rebuilder_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rebuilder_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26904;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rebuilder_delta_old" ON "dbrdf_rebuilder_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rebuilder_delta_old" ON "dbrdf_rebuilder_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rebuilder_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/rebuilder$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/rebuilder$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_rebuilder_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_rebuilder_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26904 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/rebuilder$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/rebuilder$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_rebuilder_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_rebuilder_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26904 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26904, t0.o FROM "dbrdf_rebuilder_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_rebuilder_delta_old";
        INSERT INTO "dbrdf_rebuilder_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_rebuilder_delta_new" t0;
        TRUNCATE TABLE "dbrdf_rebuilder_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 423
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_CurlingLeague_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_CurlingLeague_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26905;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_CurlingLeague_delta_old" ON "dbrdf_CurlingLeague_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_CurlingLeague_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/CurlingLeague$delta_new>(?Y) :- <http://dbpedia.org/ontology/CurlingLeague$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_CurlingLeague_delta_new"(s) SELECT t1.o FROM "dbrdf_CurlingLeague_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26905);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26905 FROM "dbrdf_CurlingLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_CurlingLeague_delta_old";
        INSERT INTO "dbrdf_CurlingLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_CurlingLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_CurlingLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 424
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_GolfLeague_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_GolfLeague_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26906;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_GolfLeague_delta_old" ON "dbrdf_GolfLeague_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_GolfLeague_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/GolfLeague$delta_new>(?Y) :- <http://dbpedia.org/ontology/GolfLeague$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_GolfLeague_delta_new"(s) SELECT t1.o FROM "dbrdf_GolfLeague_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26906);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26906 FROM "dbrdf_GolfLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_GolfLeague_delta_old";
        INSERT INTO "dbrdf_GolfLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_GolfLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_GolfLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 425
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfClassrooms_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfClassrooms_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26907;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfClassrooms_delta_old" ON "dbrdf_numberOfClassrooms_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfClassrooms_delta_old" ON "dbrdf_numberOfClassrooms_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfClassrooms_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/numberOfClassrooms$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/numberOfClassrooms$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_numberOfClassrooms_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_numberOfClassrooms_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26907 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/numberOfClassrooms$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/numberOfClassrooms$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_numberOfClassrooms_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_numberOfClassrooms_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26907 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26907, t0.o FROM "dbrdf_numberOfClassrooms_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_numberOfClassrooms_delta_old";
        INSERT INTO "dbrdf_numberOfClassrooms_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfClassrooms_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfClassrooms_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 426
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceConfluencePlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sourceConfluencePlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26908;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sourceConfluencePlace_delta_old" ON "dbrdf_sourceConfluencePlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sourceConfluencePlace_delta_old" ON "dbrdf_sourceConfluencePlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceConfluencePlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/sourceConfluencePlace$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/sourceConfluencePlace$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_sourceConfluencePlace_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_sourceConfluencePlace_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26908 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/sourceConfluencePlace$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/sourceConfluencePlace$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_sourceConfluencePlace_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_sourceConfluencePlace_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26908 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26908, t0.o FROM "dbrdf_sourceConfluencePlace_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_sourceConfluencePlace_delta_old";
        INSERT INTO "dbrdf_sourceConfluencePlace_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_sourceConfluencePlace_delta_new" t0;
        TRUNCATE TABLE "dbrdf_sourceConfluencePlace_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 427
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_isPartOfWineRegion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_isPartOfWineRegion_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26909;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_isPartOfWineRegion_delta_old" ON "dbrdf_isPartOfWineRegion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_isPartOfWineRegion_delta_old" ON "dbrdf_isPartOfWineRegion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_isPartOfWineRegion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/isPartOfWineRegion$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/isPartOfWineRegion$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_isPartOfWineRegion_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_isPartOfWineRegion_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26909 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/isPartOfWineRegion$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/isPartOfWineRegion$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_isPartOfWineRegion_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_isPartOfWineRegion_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26909 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26909, t0.o FROM "dbrdf_isPartOfWineRegion_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_isPartOfWineRegion_delta_old";
        INSERT INTO "dbrdf_isPartOfWineRegion_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_isPartOfWineRegion_delta_new" t0;
        TRUNCATE TABLE "dbrdf_isPartOfWineRegion_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 428
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_combatant_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_combatant_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26910;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_combatant_delta_old" ON "dbrdf_combatant_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_combatant_delta_old" ON "dbrdf_combatant_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_combatant_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/combatant$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/combatant$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_combatant_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_combatant_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26910 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/combatant$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/combatant$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_combatant_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_combatant_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26910 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26910, t0.o FROM "dbrdf_combatant_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_combatant_delta_old";
        INSERT INTO "dbrdf_combatant_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_combatant_delta_new" t0;
        TRUNCATE TABLE "dbrdf_combatant_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 429
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_majorityLeader_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_majorityLeader_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26911;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_majorityLeader_delta_old" ON "dbrdf_majorityLeader_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_majorityLeader_delta_old" ON "dbrdf_majorityLeader_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_majorityLeader_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/majorityLeader$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/majorityLeader$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_majorityLeader_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_majorityLeader_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26911 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/majorityLeader$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/majorityLeader$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_majorityLeader_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_majorityLeader_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26911 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26911, t0.o FROM "dbrdf_majorityLeader_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_majorityLeader_delta_old";
        INSERT INTO "dbrdf_majorityLeader_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_majorityLeader_delta_new" t0;
        TRUNCATE TABLE "dbrdf_majorityLeader_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 430
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Journalist_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Journalist_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26912;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Journalist_delta_old" ON "dbrdf_Journalist_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Journalist_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/Journalist$delta_new>(?Y) :- <http://dbpedia.org/ontology/Journalist$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Journalist_delta_new"(s) SELECT t1.o FROM "dbrdf_Journalist_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26912);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26912 FROM "dbrdf_Journalist_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Journalist_delta_old";
        INSERT INTO "dbrdf_Journalist_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Journalist_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Journalist_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 431
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_circuitName_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_circuitName_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26913;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_circuitName_delta_old" ON "dbrdf_circuitName_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_circuitName_delta_old" ON "dbrdf_circuitName_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_circuitName_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/circuitName$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/circuitName$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_circuitName_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_circuitName_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26913 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/circuitName$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/circuitName$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_circuitName_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_circuitName_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26913 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26913, t0.o FROM "dbrdf_circuitName_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_circuitName_delta_old";
        INSERT INTO "dbrdf_circuitName_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_circuitName_delta_new" t0;
        TRUNCATE TABLE "dbrdf_circuitName_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 432
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ascentDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ascentDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26914;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ascentDate_delta_old" ON "dbrdf_ascentDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ascentDate_delta_old" ON "dbrdf_ascentDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ascentDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/ascentDate$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/ascentDate$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_ascentDate_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_ascentDate_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26914 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/ascentDate$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/ascentDate$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_ascentDate_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_ascentDate_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26914 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26914, t0.o FROM "dbrdf_ascentDate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_ascentDate_delta_old";
        INSERT INTO "dbrdf_ascentDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_ascentDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ascentDate_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 433
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_isPartOfRoute_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_isPartOfRoute_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26915;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_isPartOfRoute_delta_old" ON "dbrdf_isPartOfRoute_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_isPartOfRoute_delta_old" ON "dbrdf_isPartOfRoute_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_isPartOfRoute_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/isPartOfRoute$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/isPartOfRoute$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_isPartOfRoute_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_isPartOfRoute_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26915 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/isPartOfRoute$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/isPartOfRoute$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_isPartOfRoute_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_isPartOfRoute_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26915 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26915, t0.o FROM "dbrdf_isPartOfRoute_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_isPartOfRoute_delta_old";
        INSERT INTO "dbrdf_isPartOfRoute_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_isPartOfRoute_delta_new" t0;
        TRUNCATE TABLE "dbrdf_isPartOfRoute_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 434
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_circuitLength_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_circuitLength_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26916;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_circuitLength_delta_old" ON "dbrdf_circuitLength_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_circuitLength_delta_old" ON "dbrdf_circuitLength_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_circuitLength_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/circuitLength$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/circuitLength$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_circuitLength_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_circuitLength_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26916 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/circuitLength$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/circuitLength$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_circuitLength_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_circuitLength_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26916 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26916, t0.o FROM "dbrdf_circuitLength_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_circuitLength_delta_old";
        INSERT INTO "dbrdf_circuitLength_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_circuitLength_delta_new" t0;
        TRUNCATE TABLE "dbrdf_circuitLength_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 435
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_fastestLap_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_fastestLap_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26917;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_fastestLap_delta_old" ON "dbrdf_fastestLap_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_fastestLap_delta_old" ON "dbrdf_fastestLap_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_fastestLap_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/fastestLap$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/fastestLap$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_fastestLap_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_fastestLap_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26917 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/fastestLap$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/fastestLap$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_fastestLap_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_fastestLap_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26917 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26917, t0.o FROM "dbrdf_fastestLap_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_fastestLap_delta_old";
        INSERT INTO "dbrdf_fastestLap_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_fastestLap_delta_new" t0;
        TRUNCATE TABLE "dbrdf_fastestLap_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 436
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sales_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sales_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26918;
    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, o); CREATE INDEX "IDX_1_dbrdf_sales_delta_old" ON "dbrdf_sales_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sales_delta_new"(s integer, o 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,?X1) :- <http://dbpedia.org/ontology/sales$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_sales_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_sales_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26918 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/sales$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/sales$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_sales_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_sales_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26918 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 437
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_screenActorsGuildAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_screenActorsGuildAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26919;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_screenActorsGuildAward_delta_old" ON "dbrdf_screenActorsGuildAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_screenActorsGuildAward_delta_old" ON "dbrdf_screenActorsGuildAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_screenActorsGuildAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/screenActorsGuildAward$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/screenActorsGuildAward$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_screenActorsGuildAward_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_screenActorsGuildAward_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26919 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/screenActorsGuildAward$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/screenActorsGuildAward$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_screenActorsGuildAward_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_screenActorsGuildAward_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26919 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26919, t0.o FROM "dbrdf_screenActorsGuildAward_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_screenActorsGuildAward_delta_old";
        INSERT INTO "dbrdf_screenActorsGuildAward_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_screenActorsGuildAward_delta_new" t0;
        TRUNCATE TABLE "dbrdf_screenActorsGuildAward_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 438
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_capitalElevation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_capitalElevation_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26920;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_capitalElevation_delta_old" ON "dbrdf_capitalElevation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_capitalElevation_delta_old" ON "dbrdf_capitalElevation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_capitalElevation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/capitalElevation$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/capitalElevation$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_capitalElevation_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_capitalElevation_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26920 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/capitalElevation$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/capitalElevation$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_capitalElevation_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_capitalElevation_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26920 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26920, t0.o FROM "dbrdf_capitalElevation_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_capitalElevation_delta_old";
        INSERT INTO "dbrdf_capitalElevation_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_capitalElevation_delta_new" t0;
        TRUNCATE TABLE "dbrdf_capitalElevation_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 439
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_polishFilmAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_polishFilmAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26921;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_polishFilmAward_delta_old" ON "dbrdf_polishFilmAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_polishFilmAward_delta_old" ON "dbrdf_polishFilmAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_polishFilmAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/polishFilmAward$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/polishFilmAward$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_polishFilmAward_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_polishFilmAward_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26921 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/polishFilmAward$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/polishFilmAward$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_polishFilmAward_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_polishFilmAward_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26921 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26921, t0.o FROM "dbrdf_polishFilmAward_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_polishFilmAward_delta_old";
        INSERT INTO "dbrdf_polishFilmAward_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_polishFilmAward_delta_new" t0;
        TRUNCATE TABLE "dbrdf_polishFilmAward_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 440
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cluster_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cluster_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26922;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cluster_delta_old" ON "dbrdf_cluster_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_cluster_delta_old" ON "dbrdf_cluster_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cluster_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/cluster$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/cluster$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_cluster_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_cluster_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26922 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/cluster$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/cluster$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_cluster_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_cluster_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26922 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26922, t0.o FROM "dbrdf_cluster_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_cluster_delta_old";
        INSERT INTO "dbrdf_cluster_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cluster_delta_new" t0;
        TRUNCATE TABLE "dbrdf_cluster_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 441
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Conifer_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Conifer_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26923;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Conifer_delta_old" ON "dbrdf_Conifer_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Conifer_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/Conifer$delta_new>(?Y) :- <http://dbpedia.org/ontology/Conifer$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Conifer_delta_new"(s) SELECT t1.o FROM "dbrdf_Conifer_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26923);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26923 FROM "dbrdf_Conifer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Conifer_delta_old";
        INSERT INTO "dbrdf_Conifer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Conifer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Conifer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 442
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dissolutionDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dissolutionDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26924;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dissolutionDate_delta_old" ON "dbrdf_dissolutionDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dissolutionDate_delta_old" ON "dbrdf_dissolutionDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dissolutionDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/dissolutionDate$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/dissolutionDate$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_dissolutionDate_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_dissolutionDate_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26924 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/dissolutionDate$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/dissolutionDate$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_dissolutionDate_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_dissolutionDate_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26924 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26924, t0.o FROM "dbrdf_dissolutionDate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_dissolutionDate_delta_old";
        INSERT INTO "dbrdf_dissolutionDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_dissolutionDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_dissolutionDate_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 443
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_costumeDesigner_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_costumeDesigner_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26925;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_costumeDesigner_delta_old" ON "dbrdf_costumeDesigner_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_costumeDesigner_delta_old" ON "dbrdf_costumeDesigner_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_costumeDesigner_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/costumeDesigner$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/costumeDesigner$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_costumeDesigner_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_costumeDesigner_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26925 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/costumeDesigner$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/costumeDesigner$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_costumeDesigner_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_costumeDesigner_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26925 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26925, t0.o FROM "dbrdf_costumeDesigner_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_costumeDesigner_delta_old";
        INSERT INTO "dbrdf_costumeDesigner_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_costumeDesigner_delta_new" t0;
        TRUNCATE TABLE "dbrdf_costumeDesigner_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 444
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dressCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dressCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26926;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dressCode_delta_old" ON "dbrdf_dressCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dressCode_delta_old" ON "dbrdf_dressCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dressCode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/dressCode$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/dressCode$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_dressCode_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_dressCode_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26926 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/dressCode$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/dressCode$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_dressCode_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_dressCode_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26926 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26926, t0.o FROM "dbrdf_dressCode_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_dressCode_delta_old";
        INSERT INTO "dbrdf_dressCode_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_dressCode_delta_new" t0;
        TRUNCATE TABLE "dbrdf_dressCode_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 445
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lunarSampleMass_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lunarSampleMass_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26927;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lunarSampleMass_delta_old" ON "dbrdf_lunarSampleMass_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lunarSampleMass_delta_old" ON "dbrdf_lunarSampleMass_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lunarSampleMass_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/SpaceMission/lunarSampleMass$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/SpaceMission/lunarSampleMass$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_lunarSampleMass_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_lunarSampleMass_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26927 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/SpaceMission/lunarSampleMass$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/SpaceMission/lunarSampleMass$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_lunarSampleMass_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_lunarSampleMass_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26927 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26927, t0.o FROM "dbrdf_lunarSampleMass_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_lunarSampleMass_delta_old";
        INSERT INTO "dbrdf_lunarSampleMass_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lunarSampleMass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_lunarSampleMass_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 446
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfSpeakers_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfSpeakers_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26928;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfSpeakers_delta_old" ON "dbrdf_numberOfSpeakers_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfSpeakers_delta_old" ON "dbrdf_numberOfSpeakers_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfSpeakers_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/numberOfSpeakers$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/numberOfSpeakers$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_numberOfSpeakers_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_numberOfSpeakers_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26928 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/numberOfSpeakers$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/numberOfSpeakers$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_numberOfSpeakers_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_numberOfSpeakers_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26928 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26928, t0.o FROM "dbrdf_numberOfSpeakers_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_numberOfSpeakers_delta_old";
        INSERT INTO "dbrdf_numberOfSpeakers_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfSpeakers_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfSpeakers_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 447
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_updated_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_updated_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26929;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_updated_delta_old" ON "dbrdf_updated_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_updated_delta_old" ON "dbrdf_updated_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_updated_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/updated$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/updated$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_updated_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_updated_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26929 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/updated$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/updated$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_updated_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_updated_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26929 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26929, t0.o FROM "dbrdf_updated_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_updated_delta_old";
        INSERT INTO "dbrdf_updated_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_updated_delta_new" t0;
        TRUNCATE TABLE "dbrdf_updated_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 448
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_fileSize_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_fileSize_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26930;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_fileSize_delta_old" ON "dbrdf_fileSize_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_fileSize_delta_old" ON "dbrdf_fileSize_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_fileSize_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Software/fileSize$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Software/fileSize$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_fileSize_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_fileSize_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26930 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/Software/fileSize$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/Software/fileSize$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_fileSize_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_fileSize_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26930 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26930, t0.o FROM "dbrdf_fileSize_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_fileSize_delta_old";
        INSERT INTO "dbrdf_fileSize_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_fileSize_delta_new" t0;
        TRUNCATE TABLE "dbrdf_fileSize_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 449
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_subjectOfPlay_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_subjectOfPlay_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26931;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_subjectOfPlay_delta_old" ON "dbrdf_subjectOfPlay_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_subjectOfPlay_delta_old" ON "dbrdf_subjectOfPlay_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_subjectOfPlay_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/subjectOfPlay$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/subjectOfPlay$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_subjectOfPlay_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_subjectOfPlay_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26931 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/subjectOfPlay$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/subjectOfPlay$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_subjectOfPlay_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_subjectOfPlay_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26931 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26931, t0.o FROM "dbrdf_subjectOfPlay_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_subjectOfPlay_delta_old";
        INSERT INTO "dbrdf_subjectOfPlay_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_subjectOfPlay_delta_new" t0;
        TRUNCATE TABLE "dbrdf_subjectOfPlay_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 450
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_setDesigner_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_setDesigner_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26932;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_setDesigner_delta_old" ON "dbrdf_setDesigner_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_setDesigner_delta_old" ON "dbrdf_setDesigner_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_setDesigner_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/setDesigner$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/setDesigner$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_setDesigner_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_setDesigner_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26932 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/setDesigner$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/setDesigner$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_setDesigner_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_setDesigner_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26932 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26932, t0.o FROM "dbrdf_setDesigner_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_setDesigner_delta_old";
        INSERT INTO "dbrdf_setDesigner_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_setDesigner_delta_new" t0;
        TRUNCATE TABLE "dbrdf_setDesigner_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 451
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_impactFactorAsOf_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_impactFactorAsOf_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26933;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_impactFactorAsOf_delta_old" ON "dbrdf_impactFactorAsOf_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_impactFactorAsOf_delta_old" ON "dbrdf_impactFactorAsOf_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_impactFactorAsOf_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/impactFactorAsOf$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/impactFactorAsOf$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_impactFactorAsOf_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_impactFactorAsOf_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26933 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/impactFactorAsOf$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/impactFactorAsOf$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_impactFactorAsOf_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_impactFactorAsOf_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26933 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26933, t0.o FROM "dbrdf_impactFactorAsOf_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_impactFactorAsOf_delta_old";
        INSERT INTO "dbrdf_impactFactorAsOf_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_impactFactorAsOf_delta_new" t0;
        TRUNCATE TABLE "dbrdf_impactFactorAsOf_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 452
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_administrativeCollectivity_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_administrativeCollectivity_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26934;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_administrativeCollectivity_delta_old" ON "dbrdf_administrativeCollectivity_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_administrativeCollectivity_delta_old" ON "dbrdf_administrativeCollectivity_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_administrativeCollectivity_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/administrativeCollectivity$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/administrativeCollectivity$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_administrativeCollectivity_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_administrativeCollectivity_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26934 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/administrativeCollectivity$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/administrativeCollectivity$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_administrativeCollectivity_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_administrativeCollectivity_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26934 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26934, t0.o FROM "dbrdf_administrativeCollectivity_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_administrativeCollectivity_delta_old";
        INSERT INTO "dbrdf_administrativeCollectivity_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_administrativeCollectivity_delta_new" t0;
        TRUNCATE TABLE "dbrdf_administrativeCollectivity_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 453
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_hubAirport_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_hubAirport_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26935;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_hubAirport_delta_old" ON "dbrdf_hubAirport_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_hubAirport_delta_old" ON "dbrdf_hubAirport_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_hubAirport_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/hubAirport$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/hubAirport$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_hubAirport_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_hubAirport_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26935 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/hubAirport$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/hubAirport$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_hubAirport_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_hubAirport_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26935 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26935, t0.o FROM "dbrdf_hubAirport_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_hubAirport_delta_old";
        INSERT INTO "dbrdf_hubAirport_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_hubAirport_delta_new" t0;
        TRUNCATE TABLE "dbrdf_hubAirport_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 454
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_technique_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_technique_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26936;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_technique_delta_old" ON "dbrdf_technique_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_technique_delta_old" ON "dbrdf_technique_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_technique_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/technique$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/technique$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_technique_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_technique_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26936 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/technique$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/technique$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_technique_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_technique_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26936 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26936, t0.o FROM "dbrdf_technique_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_technique_delta_old";
        INSERT INTO "dbrdf_technique_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_technique_delta_new" t0;
        TRUNCATE TABLE "dbrdf_technique_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 455
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftType_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftType_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26937;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftType_delta_old" ON "dbrdf_aircraftType_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftType_delta_old" ON "dbrdf_aircraftType_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftType_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/aircraftType$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/aircraftType$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_aircraftType_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_aircraftType_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26937 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/aircraftType$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/aircraftType$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_aircraftType_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_aircraftType_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26937 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26937, t0.o FROM "dbrdf_aircraftType_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_aircraftType_delta_old";
        INSERT INTO "dbrdf_aircraftType_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_aircraftType_delta_new" t0;
        TRUNCATE TABLE "dbrdf_aircraftType_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 456
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_minimumElevation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_minimumElevation_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26938;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_minimumElevation_delta_old" ON "dbrdf_minimumElevation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_minimumElevation_delta_old" ON "dbrdf_minimumElevation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_minimumElevation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/minimumElevation$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/minimumElevation$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_minimumElevation_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_minimumElevation_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26938 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/minimumElevation$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/minimumElevation$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_minimumElevation_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_minimumElevation_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26938 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26938, t0.o FROM "dbrdf_minimumElevation_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_minimumElevation_delta_old";
        INSERT INTO "dbrdf_minimumElevation_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_minimumElevation_delta_new" t0;
        TRUNCATE TABLE "dbrdf_minimumElevation_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 457
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_managementElevation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_managementElevation_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26939;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_managementElevation_delta_old" ON "dbrdf_managementElevation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_managementElevation_delta_old" ON "dbrdf_managementElevation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_managementElevation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/managementElevation$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/managementElevation$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_managementElevation_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_managementElevation_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26939 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/managementElevation$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/managementElevation$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_managementElevation_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_managementElevation_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26939 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26939, t0.o FROM "dbrdf_managementElevation_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_managementElevation_delta_old";
        INSERT INTO "dbrdf_managementElevation_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_managementElevation_delta_new" t0;
        TRUNCATE TABLE "dbrdf_managementElevation_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 458
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsSoiusaCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_alpsSoiusaCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26940;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_alpsSoiusaCode_delta_old" ON "dbrdf_alpsSoiusaCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_alpsSoiusaCode_delta_old" ON "dbrdf_alpsSoiusaCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsSoiusaCode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/alpsSoiusaCode$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/alpsSoiusaCode$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_alpsSoiusaCode_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_alpsSoiusaCode_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26940 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/alpsSoiusaCode$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/alpsSoiusaCode$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_alpsSoiusaCode_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_alpsSoiusaCode_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26940 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26940, t0.o FROM "dbrdf_alpsSoiusaCode_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_alpsSoiusaCode_delta_old";
        INSERT INTO "dbrdf_alpsSoiusaCode_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_alpsSoiusaCode_delta_new" t0;
        TRUNCATE TABLE "dbrdf_alpsSoiusaCode_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 459
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_musicFusionGenre_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_musicFusionGenre_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26941;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_musicFusionGenre_delta_old" ON "dbrdf_musicFusionGenre_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_musicFusionGenre_delta_old" ON "dbrdf_musicFusionGenre_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_musicFusionGenre_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/musicFusionGenre$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/musicFusionGenre$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_musicFusionGenre_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_musicFusionGenre_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26941 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/musicFusionGenre$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/musicFusionGenre$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_musicFusionGenre_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_musicFusionGenre_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26941 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26941, t0.o FROM "dbrdf_musicFusionGenre_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_musicFusionGenre_delta_old";
        INSERT INTO "dbrdf_musicFusionGenre_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_musicFusionGenre_delta_new" t0;
        TRUNCATE TABLE "dbrdf_musicFusionGenre_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 460
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_managerClub_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_managerClub_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26942;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_managerClub_delta_old" ON "dbrdf_managerClub_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_managerClub_delta_old" ON "dbrdf_managerClub_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_managerClub_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/managerClub$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/managerClub$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_managerClub_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_managerClub_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26942 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/managerClub$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/managerClub$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_managerClub_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_managerClub_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26942 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26942, t0.o FROM "dbrdf_managerClub_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_managerClub_delta_old";
        INSERT INTO "dbrdf_managerClub_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_managerClub_delta_new" t0;
        TRUNCATE TABLE "dbrdf_managerClub_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 461
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceState_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sourceState_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26943;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sourceState_delta_old" ON "dbrdf_sourceState_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sourceState_delta_old" ON "dbrdf_sourceState_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceState_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/sourceState$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/sourceState$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_sourceState_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_sourceState_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26943 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/sourceState$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/sourceState$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_sourceState_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_sourceState_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26943 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26943, t0.o FROM "dbrdf_sourceState_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_sourceState_delta_old";
        INSERT INTO "dbrdf_sourceState_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_sourceState_delta_new" t0;
        TRUNCATE TABLE "dbrdf_sourceState_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 462
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtSun_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtSun_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26944;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtSun_delta_old" ON "dbrdf_winsAtSun_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtSun_delta_old" ON "dbrdf_winsAtSun_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtSun_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/winsAtSun$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/winsAtSun$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_winsAtSun_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_winsAtSun_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26944 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/winsAtSun$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/winsAtSun$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_winsAtSun_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_winsAtSun_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26944 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26944, t0.o FROM "dbrdf_winsAtSun_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_winsAtSun_delta_old";
        INSERT INTO "dbrdf_winsAtSun_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_winsAtSun_delta_new" t0;
        TRUNCATE TABLE "dbrdf_winsAtSun_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 463
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_americanComedyAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_americanComedyAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26945;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_americanComedyAward_delta_old" ON "dbrdf_americanComedyAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_americanComedyAward_delta_old" ON "dbrdf_americanComedyAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_americanComedyAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/americanComedyAward$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/americanComedyAward$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_americanComedyAward_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_americanComedyAward_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26945 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/americanComedyAward$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/americanComedyAward$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_americanComedyAward_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_americanComedyAward_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26945 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26945, t0.o FROM "dbrdf_americanComedyAward_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_americanComedyAward_delta_old";
        INSERT INTO "dbrdf_americanComedyAward_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_americanComedyAward_delta_new" t0;
        TRUNCATE TABLE "dbrdf_americanComedyAward_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 464
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cmykCoordinateBlack_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cmykCoordinateBlack_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26946;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cmykCoordinateBlack_delta_old" ON "dbrdf_cmykCoordinateBlack_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_cmykCoordinateBlack_delta_old" ON "dbrdf_cmykCoordinateBlack_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cmykCoordinateBlack_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/cmykCoordinateBlack$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/cmykCoordinateBlack$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_cmykCoordinateBlack_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_cmykCoordinateBlack_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26946 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/cmykCoordinateBlack$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/cmykCoordinateBlack$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_cmykCoordinateBlack_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_cmykCoordinateBlack_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26946 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26946, t0.o FROM "dbrdf_cmykCoordinateBlack_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_cmykCoordinateBlack_delta_old";
        INSERT INTO "dbrdf_cmykCoordinateBlack_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cmykCoordinateBlack_delta_new" t0;
        TRUNCATE TABLE "dbrdf_cmykCoordinateBlack_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 465
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nrhpType_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nrhpType_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26947;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nrhpType_delta_old" ON "dbrdf_nrhpType_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nrhpType_delta_old" ON "dbrdf_nrhpType_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nrhpType_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/nrhpType$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/nrhpType$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_nrhpType_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_nrhpType_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26947 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/nrhpType$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/nrhpType$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_nrhpType_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_nrhpType_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26947 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26947, t0.o FROM "dbrdf_nrhpType_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_nrhpType_delta_old";
        INSERT INTO "dbrdf_nrhpType_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_nrhpType_delta_new" t0;
        TRUNCATE TABLE "dbrdf_nrhpType_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 466
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_RugbyPlayer_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_RugbyPlayer_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26948;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_RugbyPlayer_delta_old" ON "dbrdf_RugbyPlayer_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_RugbyPlayer_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/RugbyPlayer$delta_new>(?Y) :- <http://dbpedia.org/ontology/RugbyPlayer$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_RugbyPlayer_delta_new"(s) SELECT t1.o FROM "dbrdf_RugbyPlayer_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26948);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26948 FROM "dbrdf_RugbyPlayer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_RugbyPlayer_delta_old";
        INSERT INTO "dbrdf_RugbyPlayer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_RugbyPlayer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_RugbyPlayer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 467
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 468
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 469
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 470
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_distance_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_distance_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26952;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_distance_delta_old0" ON "dbrdf_distance_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_distance_delta_old0" ON "dbrdf_distance_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_distance_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26952, t0.o FROM "dbrdf_distance_delta_new0" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_distance_delta_old0";
        INSERT INTO "dbrdf_distance_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_distance_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_distance_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 471
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 472
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 473
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

