        INSERT INTO "dbrdf_governmentCountry_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_governmentCountry_delta_new" t0;
        TRUNCATE TABLE "dbrdf_governmentCountry_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 137
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_endYearOfSales_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_endYearOfSales_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_endYearOfSales" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_endYearOfSales_delta_old" ON "dbrdf_endYearOfSales_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_endYearOfSales_delta_old" ON "dbrdf_endYearOfSales_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_endYearOfSales_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 138
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_growingGrape_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_growingGrape_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_growingGrape" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_growingGrape_delta_old" ON "dbrdf_growingGrape_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_growingGrape_delta_old" ON "dbrdf_growingGrape_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_growingGrape_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 139
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_drugbank_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_drugbank_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_drugbank" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_drugbank_delta_old" ON "dbrdf_drugbank_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_drugbank_delta_old" ON "dbrdf_drugbank_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_drugbank_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 140
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_FieldHockeyLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_FieldHockeyLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_FieldHockeyLeague_delta_old";
        INSERT INTO "dbrdf_FieldHockeyLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_FieldHockeyLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_FieldHockeyLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 141
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_maidenFlight_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_maidenFlight_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_maidenFlight" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_maidenFlight_delta_old" ON "dbrdf_maidenFlight_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_maidenFlight_delta_old" ON "dbrdf_maidenFlight_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_maidenFlight_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 142
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_minorityFloorLeader_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_minorityFloorLeader_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_minorityFloorLeader" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_minorityFloorLeader_delta_old" ON "dbrdf_minorityFloorLeader_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_minorityFloorLeader_delta_old" ON "dbrdf_minorityFloorLeader_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_minorityFloorLeader_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 143
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_britishComedyAwards_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_britishComedyAwards_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_britishComedyAwards" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_britishComedyAwards_delta_old" ON "dbrdf_britishComedyAwards_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_britishComedyAwards_delta_old" ON "dbrdf_britishComedyAwards_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_britishComedyAwards_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 144
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_silCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_silCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_silCode" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_silCode_delta_old" ON "dbrdf_silCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_silCode_delta_old" ON "dbrdf_silCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_silCode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 145
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_port1DockedTime_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_port1DockedTime_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_port1DockedTime" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_port1DockedTime_delta_old" ON "dbrdf_port1DockedTime_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_port1DockedTime_delta_old" ON "dbrdf_port1DockedTime_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_port1DockedTime_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 146
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Governor"(s) SELECT DISTINCT t0.s FROM "dbrdf_Governor_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Governor_delta_old";
        INSERT INTO "dbrdf_Governor_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Governor_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Governor_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 147
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_meshName_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_meshName_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_meshName" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_meshName_delta_old" ON "dbrdf_meshName_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_meshName_delta_old" ON "dbrdf_meshName_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_meshName_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 148
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_canonizedPlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_canonizedPlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_canonizedPlace" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_canonizedPlace_delta_old" ON "dbrdf_canonizedPlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_canonizedPlace_delta_old" ON "dbrdf_canonizedPlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_canonizedPlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 149
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_inn_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_inn_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_inn" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_inn_delta_old" ON "dbrdf_inn_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_inn_delta_old" ON "dbrdf_inn_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_inn_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 150
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_designer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_designer_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_designer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_designer_delta_old" ON "dbrdf_designer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_designer_delta_old" ON "dbrdf_designer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_designer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 151
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_majorLake_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_majorLake_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_majorLake" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_majorLake_delta_old" ON "dbrdf_majorLake_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_majorLake_delta_old" ON "dbrdf_majorLake_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_majorLake_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 152
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sessionNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sessionNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_sessionNumber" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sessionNumber_delta_old" ON "dbrdf_sessionNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sessionNumber_delta_old" ON "dbrdf_sessionNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sessionNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 153
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_vehicle_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_vehicle_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_vehicle" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_vehicle_delta_old" ON "dbrdf_vehicle_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_vehicle_delta_old" ON "dbrdf_vehicle_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_vehicle_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 154
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_BowlingLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_BowlingLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_BowlingLeague_delta_old";
        INSERT INTO "dbrdf_BowlingLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_BowlingLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_BowlingLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 155
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lowerEarthOrbitPayload_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lowerEarthOrbitPayload_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lowerEarthOrbitPayload" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lowerEarthOrbitPayload_delta_old" ON "dbrdf_lowerEarthOrbitPayload_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lowerEarthOrbitPayload_delta_old" ON "dbrdf_lowerEarthOrbitPayload_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lowerEarthOrbitPayload_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 156
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_areaCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_areaCode" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_areaCode_delta_old" ON "dbrdf_areaCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_areaCode_delta_old" ON "dbrdf_areaCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaCode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 157
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_basedOn_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_basedOn_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_basedOn" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_basedOn_delta_old" ON "dbrdf_basedOn_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_basedOn_delta_old" ON "dbrdf_basedOn_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_basedOn_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 158
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_premiereDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_premiereDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_premiereDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_premiereDate_delta_old" ON "dbrdf_premiereDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_premiereDate_delta_old" ON "dbrdf_premiereDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_premiereDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 159
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_TelevisionSeason"(s) SELECT DISTINCT t0.s FROM "dbrdf_TelevisionSeason_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_TelevisionSeason_delta_old";
        INSERT INTO "dbrdf_TelevisionSeason_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_TelevisionSeason_delta_new" t0;
        TRUNCATE TABLE "dbrdf_TelevisionSeason_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 160
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ingredient_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ingredient_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_ingredient" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ingredient_delta_old" ON "dbrdf_ingredient_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ingredient_delta_old" ON "dbrdf_ingredient_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ingredient_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 161
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_locusSupplementaryData_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_locusSupplementaryData_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_locusSupplementaryData" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_locusSupplementaryData_delta_old" ON "dbrdf_locusSupplementaryData_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_locusSupplementaryData_delta_old" ON "dbrdf_locusSupplementaryData_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_locusSupplementaryData_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 162
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_soccerTournamentClosingSeason_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_soccerTournamentClosingSeason_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_soccerTournamentClosingSeason" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_soccerTournamentClosingSeason_delta_old" ON "dbrdf_soccerTournamentClosingSeason_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_soccerTournamentClosingSeason_delta_old" ON "dbrdf_soccerTournamentClosingSeason_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_soccerTournamentClosingSeason_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 163
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rankingWins_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rankingWins_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_rankingWins" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rankingWins_delta_old" ON "dbrdf_rankingWins_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rankingWins_delta_old" ON "dbrdf_rankingWins_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rankingWins_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 164
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_diseasesdb_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_diseasesdb_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_diseasesdb" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_diseasesdb_delta_old" ON "dbrdf_diseasesdb_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_diseasesdb_delta_old" ON "dbrdf_diseasesdb_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_diseasesdb_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 165
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_soocerLeagueWinner_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_soocerLeagueWinner_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_soocerLeagueWinner" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_soocerLeagueWinner_delta_old" ON "dbrdf_soocerLeagueWinner_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_soocerLeagueWinner_delta_old" ON "dbrdf_soocerLeagueWinner_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_soocerLeagueWinner_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 166
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_HumanGeneLocation"(s) SELECT DISTINCT t0.s FROM "dbrdf_HumanGeneLocation_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_HumanGeneLocation_delta_old";
        INSERT INTO "dbrdf_HumanGeneLocation_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_HumanGeneLocation_delta_new" t0;
        TRUNCATE TABLE "dbrdf_HumanGeneLocation_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 167
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sublimationPoint_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sublimationPoint_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_sublimationPoint" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sublimationPoint_delta_old" ON "dbrdf_sublimationPoint_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sublimationPoint_delta_old" ON "dbrdf_sublimationPoint_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sublimationPoint_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 168
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_testaverage_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_testaverage_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_testaverage" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_testaverage_delta_old" ON "dbrdf_testaverage_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_testaverage_delta_old" ON "dbrdf_testaverage_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_testaverage_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 169
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_starring_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_starring_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_starring" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_starring_delta_old" ON "dbrdf_starring_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_starring_delta_old" ON "dbrdf_starring_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_starring_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 170
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfAlbums_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfAlbums_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfAlbums" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfAlbums_delta_old" ON "dbrdf_numberOfAlbums_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfAlbums_delta_old" ON "dbrdf_numberOfAlbums_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfAlbums_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 171
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_owningCompany_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_owningCompany_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_owningCompany" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_owningCompany_delta_old" ON "dbrdf_owningCompany_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_owningCompany_delta_old" ON "dbrdf_owningCompany_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_owningCompany_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 172
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Judge"(s) SELECT DISTINCT t0.s FROM "dbrdf_Judge_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Judge_delta_old";
        INSERT INTO "dbrdf_Judge_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Judge_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Judge_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 173
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_runwaySurface_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_runwaySurface_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_runwaySurface" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_runwaySurface_delta_old" ON "dbrdf_runwaySurface_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_runwaySurface_delta_old" ON "dbrdf_runwaySurface_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_runwaySurface_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 174
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_captureDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_captureDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_captureDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_captureDate_delta_old" ON "dbrdf_captureDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_captureDate_delta_old" ON "dbrdf_captureDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_captureDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 175
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dischargeAverage_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dischargeAverage_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_dischargeAverage" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dischargeAverage_delta_old" ON "dbrdf_dischargeAverage_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dischargeAverage_delta_old" ON "dbrdf_dischargeAverage_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dischargeAverage_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 176
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_coverArtist_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_coverArtist_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_coverArtist" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_coverArtist_delta_old" ON "dbrdf_coverArtist_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_coverArtist_delta_old" ON "dbrdf_coverArtist_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_coverArtist_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 177
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceMountain_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sourceMountain_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_sourceMountain" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sourceMountain_delta_old" ON "dbrdf_sourceMountain_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sourceMountain_delta_old" ON "dbrdf_sourceMountain_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceMountain_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 178
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rebuildingDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rebuildingDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_rebuildingDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rebuildingDate_delta_old" ON "dbrdf_rebuildingDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rebuildingDate_delta_old" ON "dbrdf_rebuildingDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rebuildingDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 179
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_literaryGenre_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_literaryGenre_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_literaryGenre" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_literaryGenre_delta_old" ON "dbrdf_literaryGenre_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_literaryGenre_delta_old" ON "dbrdf_literaryGenre_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_literaryGenre_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 180
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_colour_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_colour_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_colour" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_colour_delta_old" ON "dbrdf_colour_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_colour_delta_old" ON "dbrdf_colour_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_colour_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 181
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_managerTitle_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_managerTitle_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_managerTitle" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_managerTitle_delta_old" ON "dbrdf_managerTitle_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_managerTitle_delta_old" ON "dbrdf_managerTitle_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_managerTitle_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 182
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_periapsis_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_periapsis_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_periapsis" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_periapsis_delta_old" ON "dbrdf_periapsis_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_periapsis_delta_old" ON "dbrdf_periapsis_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_periapsis_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 183
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 184
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstLaunchDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstLaunchDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_firstLaunchDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstLaunchDate_delta_old" ON "dbrdf_firstLaunchDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstLaunchDate_delta_old" ON "dbrdf_firstLaunchDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstLaunchDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 185
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_surfaceFormOccurrenceOffset_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_surfaceFormOccurrenceOffset_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_surfaceFormOccurrenceOffset" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_surfaceFormOccurrenceOffset_delta_old" ON "dbrdf_surfaceFormOccurrenceOffset_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_surfaceFormOccurrenceOffset_delta_old" ON "dbrdf_surfaceFormOccurrenceOffset_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_surfaceFormOccurrenceOffset_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 186
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_musicalArtist_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_musicalArtist_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_musicalArtist" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_musicalArtist_delta_old" ON "dbrdf_musicalArtist_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_musicalArtist_delta_old" ON "dbrdf_musicalArtist_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_musicalArtist_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 187
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_width0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_width_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_width_delta_old0";
        INSERT INTO "dbrdf_width_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_width_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_width_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 188
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_militaryCommand_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_militaryCommand_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_militaryCommand" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_militaryCommand_delta_old" ON "dbrdf_militaryCommand_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_militaryCommand_delta_old" ON "dbrdf_militaryCommand_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_militaryCommand_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 189
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Muscle"(s) SELECT DISTINCT t0.s FROM "dbrdf_Muscle_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Muscle_delta_old";
        INSERT INTO "dbrdf_Muscle_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Muscle_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Muscle_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 190
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_personFunction_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_personFunction_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_personFunction" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_personFunction_delta_old" ON "dbrdf_personFunction_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_personFunction_delta_old" ON "dbrdf_personFunction_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_personFunction_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 191
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_languageRegulator_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_languageRegulator_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_languageRegulator" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_languageRegulator_delta_old" ON "dbrdf_languageRegulator_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_languageRegulator_delta_old" ON "dbrdf_languageRegulator_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_languageRegulator_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 192
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaTotal_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_areaTotal_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_areaTotal" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_areaTotal_delta_old" ON "dbrdf_areaTotal_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_areaTotal_delta_old" ON "dbrdf_areaTotal_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaTotal_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 193
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_RadioControlledRacingLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_RadioControlledRacingLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_RadioControlledRacingLeague_delta_old";
        INSERT INTO "dbrdf_RadioControlledRacingLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_RadioControlledRacingLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_RadioControlledRacingLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 194
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_musicComposer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_musicComposer_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_musicComposer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_musicComposer_delta_old" ON "dbrdf_musicComposer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_musicComposer_delta_old" ON "dbrdf_musicComposer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_musicComposer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 195
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_modelStartDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_modelStartDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_modelStartDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_modelStartDate_delta_old" ON "dbrdf_modelStartDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_modelStartDate_delta_old" ON "dbrdf_modelStartDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_modelStartDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 196
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_BasketballPlayer"(s) SELECT DISTINCT t0.s FROM "dbrdf_BasketballPlayer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_BasketballPlayer_delta_old";
        INSERT INTO "dbrdf_BasketballPlayer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_BasketballPlayer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_BasketballPlayer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 197
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_soccerTournamentMostSteady_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_soccerTournamentMostSteady_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_soccerTournamentMostSteady" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_soccerTournamentMostSteady_delta_old" ON "dbrdf_soccerTournamentMostSteady_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_soccerTournamentMostSteady_delta_old" ON "dbrdf_soccerTournamentMostSteady_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_soccerTournamentMostSteady_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 198
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_title_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_title_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_title" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_title_delta_old" ON "dbrdf_title_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_title_delta_old" ON "dbrdf_title_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_title_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 199
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ascent_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ascent_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_ascent" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ascent_delta_old" ON "dbrdf_ascent_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ascent_delta_old" ON "dbrdf_ascent_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ascent_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 200
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_officerInCharge_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_officerInCharge_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_officerInCharge" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_officerInCharge_delta_old" ON "dbrdf_officerInCharge_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_officerInCharge_delta_old" ON "dbrdf_officerInCharge_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_officerInCharge_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 201
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_youthWing_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_youthWing_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_youthWing" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_youthWing_delta_old" ON "dbrdf_youthWing_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_youthWing_delta_old" ON "dbrdf_youthWing_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_youthWing_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 202
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtLAGT_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtLAGT_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_winsAtLAGT" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtLAGT_delta_old" ON "dbrdf_winsAtLAGT_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtLAGT_delta_old" ON "dbrdf_winsAtLAGT_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtLAGT_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 203
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtLET_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtLET_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_winsAtLET" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtLET_delta_old" ON "dbrdf_winsAtLET_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtLET_delta_old" ON "dbrdf_winsAtLET_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtLET_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 204
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_senator_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_senator_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_senator" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_senator_delta_old" ON "dbrdf_senator_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_senator_delta_old" ON "dbrdf_senator_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_senator_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 205
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_shipBeam_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_shipBeam_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_shipBeam" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_shipBeam_delta_old" ON "dbrdf_shipBeam_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_shipBeam_delta_old" ON "dbrdf_shipBeam_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_shipBeam_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 206
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_draft_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_draft_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_draft" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_draft_delta_old" ON "dbrdf_draft_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_draft_delta_old" ON "dbrdf_draft_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_draft_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 207
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_licensee_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_licensee_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_licensee" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_licensee_delta_old" ON "dbrdf_licensee_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_licensee_delta_old" ON "dbrdf_licensee_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_licensee_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 208
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_ChristianPatriarch"(s) SELECT DISTINCT t0.s FROM "dbrdf_ChristianPatriarch_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_ChristianPatriarch_delta_old";
        INSERT INTO "dbrdf_ChristianPatriarch_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_ChristianPatriarch_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ChristianPatriarch_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 209
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_councilArea_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_councilArea_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_councilArea" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_councilArea_delta_old" ON "dbrdf_councilArea_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_councilArea_delta_old" ON "dbrdf_councilArea_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_councilArea_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 210
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_loadLimit_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_loadLimit_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_loadLimit" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_loadLimit_delta_old" ON "dbrdf_loadLimit_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_loadLimit_delta_old" ON "dbrdf_loadLimit_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_loadLimit_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 211
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_yearOfElectrification_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_yearOfElectrification_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_yearOfElectrification" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_yearOfElectrification_delta_old" ON "dbrdf_yearOfElectrification_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_yearOfElectrification_delta_old" ON "dbrdf_yearOfElectrification_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_yearOfElectrification_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 212
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cuisine_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cuisine_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_cuisine" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cuisine_delta_old" ON "dbrdf_cuisine_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_cuisine_delta_old" ON "dbrdf_cuisine_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cuisine_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 213
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lounge_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lounge_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lounge" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lounge_delta_old" ON "dbrdf_lounge_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lounge_delta_old" ON "dbrdf_lounge_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lounge_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 214
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_wikiPageID_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_wikiPageID_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_wikiPageID" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_wikiPageID_delta_old" ON "dbrdf_wikiPageID_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_wikiPageID_delta_old" ON "dbrdf_wikiPageID_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_wikiPageID_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 215
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_atcPrefix_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_atcPrefix_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_atcPrefix" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_atcPrefix_delta_old" ON "dbrdf_atcPrefix_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_atcPrefix_delta_old" ON "dbrdf_atcPrefix_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_atcPrefix_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 216
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfTracks_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfTracks_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfTracks" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfTracks_delta_old" ON "dbrdf_numberOfTracks_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfTracks_delta_old" ON "dbrdf_numberOfTracks_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfTracks_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 217
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_patent_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_patent_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_patent" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_patent_delta_old" ON "dbrdf_patent_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_patent_delta_old" ON "dbrdf_patent_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_patent_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 218
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_publicationDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_publicationDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_publicationDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_publicationDate_delta_old" ON "dbrdf_publicationDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_publicationDate_delta_old" ON "dbrdf_publicationDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_publicationDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 219
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_bronzeMedalist_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_bronzeMedalist_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_bronzeMedalist" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_bronzeMedalist_delta_old" ON "dbrdf_bronzeMedalist_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_bronzeMedalist_delta_old" ON "dbrdf_bronzeMedalist_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_bronzeMedalist_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 220
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_annualTemperature_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_annualTemperature_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_annualTemperature" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_annualTemperature_delta_old" ON "dbrdf_annualTemperature_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_annualTemperature_delta_old" ON "dbrdf_annualTemperature_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_annualTemperature_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 221
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_individualisedPnd_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_individualisedPnd_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_individualisedPnd" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_individualisedPnd_delta_old" ON "dbrdf_individualisedPnd_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_individualisedPnd_delta_old" ON "dbrdf_individualisedPnd_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_individualisedPnd_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 222
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_secondPopularVote_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_secondPopularVote_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_secondPopularVote" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_secondPopularVote_delta_old" ON "dbrdf_secondPopularVote_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_secondPopularVote_delta_old" ON "dbrdf_secondPopularVote_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_secondPopularVote_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 223
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_education_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_education_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_education" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_education_delta_old" ON "dbrdf_education_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_education_delta_old" ON "dbrdf_education_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_education_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 224
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_crosses_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_crosses_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_crosses" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_crosses_delta_old" ON "dbrdf_crosses_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_crosses_delta_old" ON "dbrdf_crosses_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_crosses_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 225
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_doctoralAdvisor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_doctoralAdvisor_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_doctoralAdvisor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_doctoralAdvisor_delta_old" ON "dbrdf_doctoralAdvisor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_doctoralAdvisor_delta_old" ON "dbrdf_doctoralAdvisor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_doctoralAdvisor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 226
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rebuildDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rebuildDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_rebuildDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rebuildDate_delta_old" ON "dbrdf_rebuildDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rebuildDate_delta_old" ON "dbrdf_rebuildDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rebuildDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 227
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_government_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_government_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_government" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_government_delta_old" ON "dbrdf_government_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_government_delta_old" ON "dbrdf_government_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_government_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 228
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_goldenGlobeAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_goldenGlobeAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_goldenGlobeAward" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_goldenGlobeAward_delta_old" ON "dbrdf_goldenGlobeAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_goldenGlobeAward_delta_old" ON "dbrdf_goldenGlobeAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_goldenGlobeAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 229
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_imageSize_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_imageSize_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_imageSize" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_imageSize_delta_old" ON "dbrdf_imageSize_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_imageSize_delta_old" ON "dbrdf_imageSize_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_imageSize_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 230
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfGoldMedalsWon_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfGoldMedalsWon_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfGoldMedalsWon" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfGoldMedalsWon_delta_old" ON "dbrdf_numberOfGoldMedalsWon_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfGoldMedalsWon_delta_old" ON "dbrdf_numberOfGoldMedalsWon_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfGoldMedalsWon_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 231
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_militaryBranch_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_militaryBranch_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_militaryBranch" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_militaryBranch_delta_old" ON "dbrdf_militaryBranch_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_militaryBranch_delta_old" ON "dbrdf_militaryBranch_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_militaryBranch_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 232
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_commissioningDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_commissioningDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_commissioningDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_commissioningDate_delta_old" ON "dbrdf_commissioningDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_commissioningDate_delta_old" ON "dbrdf_commissioningDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_commissioningDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 233
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_drainsFrom_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_drainsFrom_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_drainsFrom" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_drainsFrom_delta_old" ON "dbrdf_drainsFrom_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_drainsFrom_delta_old" ON "dbrdf_drainsFrom_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_drainsFrom_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 234
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_previousInfrastructure_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_previousInfrastructure_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_previousInfrastructure" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_previousInfrastructure_delta_old" ON "dbrdf_previousInfrastructure_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_previousInfrastructure_delta_old" ON "dbrdf_previousInfrastructure_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_previousInfrastructure_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 235
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_politicGovernmentDepartment_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_politicGovernmentDepartment_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_politicGovernmentDepartment" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_politicGovernmentDepartment_delta_old" ON "dbrdf_politicGovernmentDepartment_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_politicGovernmentDepartment_delta_old" ON "dbrdf_politicGovernmentDepartment_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_politicGovernmentDepartment_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 236
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_currentProduction_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_currentProduction_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_currentProduction" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_currentProduction_delta_old" ON "dbrdf_currentProduction_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_currentProduction_delta_old" ON "dbrdf_currentProduction_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_currentProduction_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 237
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_meetingBuilding_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_meetingBuilding_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_meetingBuilding" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_meetingBuilding_delta_old" ON "dbrdf_meetingBuilding_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_meetingBuilding_delta_old" ON "dbrdf_meetingBuilding_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_meetingBuilding_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 238
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_assistantPrincipal_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_assistantPrincipal_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_assistantPrincipal" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_assistantPrincipal_delta_old" ON "dbrdf_assistantPrincipal_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_assistantPrincipal_delta_old" ON "dbrdf_assistantPrincipal_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_assistantPrincipal_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 239
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_namedAfter_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_namedAfter_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_namedAfter" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_namedAfter_delta_old" ON "dbrdf_namedAfter_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_namedAfter_delta_old" ON "dbrdf_namedAfter_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_namedAfter_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 240
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_railwayLineUsingTunnel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_railwayLineUsingTunnel_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_railwayLineUsingTunnel" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_railwayLineUsingTunnel_delta_old" ON "dbrdf_railwayLineUsingTunnel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_railwayLineUsingTunnel_delta_old" ON "dbrdf_railwayLineUsingTunnel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_railwayLineUsingTunnel_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 241
    ---- DEPENDS ON: 240, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_RailwayTunnel"(s) SELECT DISTINCT t0.s FROM "dbrdf_RailwayTunnel_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_RailwayTunnel_delta_old";
        INSERT INTO "dbrdf_RailwayTunnel_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_RailwayTunnel_delta_new" t0;
        TRUNCATE TABLE "dbrdf_RailwayTunnel_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 242
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Fern"(s) SELECT DISTINCT t0.s FROM "dbrdf_Fern_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Fern_delta_old";
        INSERT INTO "dbrdf_Fern_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Fern_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Fern_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 243
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mouthPlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mouthPlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_mouthPlace" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mouthPlace_delta_old" ON "dbrdf_mouthPlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mouthPlace_delta_old" ON "dbrdf_mouthPlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mouthPlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 244
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_railwayPlatforms_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_railwayPlatforms_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_railwayPlatforms" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_railwayPlatforms_delta_old" ON "dbrdf_railwayPlatforms_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_railwayPlatforms_delta_old" ON "dbrdf_railwayPlatforms_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_railwayPlatforms_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 245
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Valley"(s) SELECT DISTINCT t0.s FROM "dbrdf_Valley_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Valley_delta_old";
        INSERT INTO "dbrdf_Valley_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Valley_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Valley_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 246
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationPlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_populationPlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_populationPlace" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_populationPlace_delta_old" ON "dbrdf_populationPlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_populationPlace_delta_old" ON "dbrdf_populationPlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationPlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 247
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_grammyAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_grammyAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_grammyAward" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_grammyAward_delta_old" ON "dbrdf_grammyAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_grammyAward_delta_old" ON "dbrdf_grammyAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_grammyAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 248
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_vehiclesPerDay_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_vehiclesPerDay_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_vehiclesPerDay" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_vehiclesPerDay_delta_old" ON "dbrdf_vehiclesPerDay_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_vehiclesPerDay_delta_old" ON "dbrdf_vehiclesPerDay_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_vehiclesPerDay_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 249
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_restingPlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_restingPlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_restingPlace" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_restingPlace_delta_old" ON "dbrdf_restingPlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_restingPlace_delta_old" ON "dbrdf_restingPlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_restingPlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 250
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_taoiseach_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_taoiseach_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_taoiseach" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_taoiseach_delta_old" ON "dbrdf_taoiseach_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_taoiseach_delta_old" ON "dbrdf_taoiseach_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_taoiseach_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 251
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_map_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_map_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_map" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_map_delta_old" ON "dbrdf_map_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_map_delta_old" ON "dbrdf_map_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_map_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 252
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_europeanAffiliation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_europeanAffiliation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_europeanAffiliation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_europeanAffiliation_delta_old" ON "dbrdf_europeanAffiliation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_europeanAffiliation_delta_old" ON "dbrdf_europeanAffiliation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_europeanAffiliation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 253
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Referee"(s) SELECT DISTINCT t0.s FROM "dbrdf_Referee_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Referee_delta_old";
        INSERT INTO "dbrdf_Referee_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Referee_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Referee_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 254
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_president_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_president_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_president" t0;
    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, o); CREATE INDEX "IDX_1_dbrdf_president_delta_old" ON "dbrdf_president_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_president_delta_new"(s integer, o 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,?X1) :- <http://dbpedia.org/ontology/president$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_president_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_president_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_president" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 255
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mainspan_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mainspan_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_mainspan" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mainspan_delta_old" ON "dbrdf_mainspan_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mainspan_delta_old" ON "dbrdf_mainspan_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mainspan_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 256
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_automobilePlatform_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_automobilePlatform_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_automobilePlatform" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_automobilePlatform_delta_old" ON "dbrdf_automobilePlatform_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_automobilePlatform_delta_old" ON "dbrdf_automobilePlatform_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_automobilePlatform_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 257
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_tvComId_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_tvComId_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_tvComId" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_tvComId_delta_old" ON "dbrdf_tvComId_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_tvComId_delta_old" ON "dbrdf_tvComId_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_tvComId_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 258
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_writer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_writer_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_writer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_writer_delta_old" ON "dbrdf_writer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_writer_delta_old" ON "dbrdf_writer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_writer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 259
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_temperature_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_temperature_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_temperature" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_temperature_delta_old" ON "dbrdf_temperature_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_temperature_delta_old" ON "dbrdf_temperature_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_temperature_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 260
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_commandStructure_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_commandStructure_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_commandStructure" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_commandStructure_delta_old" ON "dbrdf_commandStructure_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_commandStructure_delta_old" ON "dbrdf_commandStructure_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_commandStructure_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 261
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_coachingRecord_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_coachingRecord_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_coachingRecord" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_coachingRecord_delta_old" ON "dbrdf_coachingRecord_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_coachingRecord_delta_old" ON "dbrdf_coachingRecord_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_coachingRecord_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 262
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_dischargeAverage0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_dischargeAverage_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_dischargeAverage_delta_old0";
        INSERT INTO "dbrdf_dischargeAverage_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_dischargeAverage_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_dischargeAverage_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 263
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_deathCause_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_deathCause_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_deathCause" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_deathCause_delta_old" ON "dbrdf_deathCause_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_deathCause_delta_old" ON "dbrdf_deathCause_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_deathCause_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 264
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_disbanded_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_disbanded_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_disbanded" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_disbanded_delta_old" ON "dbrdf_disbanded_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_disbanded_delta_old" ON "dbrdf_disbanded_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_disbanded_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 265
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_musicians_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_musicians_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_musicians" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_musicians_delta_old" ON "dbrdf_musicians_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_musicians_delta_old" ON "dbrdf_musicians_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_musicians_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 266
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_residence_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_residence_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_residence" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_residence_delta_old" ON "dbrdf_residence_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_residence_delta_old" ON "dbrdf_residence_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_residence_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 267
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_bandMember_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_bandMember_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_bandMember" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_bandMember_delta_old" ON "dbrdf_bandMember_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_bandMember_delta_old" ON "dbrdf_bandMember_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_bandMember_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 268
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_humanDevelopmentIndexAsOf_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_humanDevelopmentIndexAsOf_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_humanDevelopmentIndexAsOf" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_humanDevelopmentIndexAsOf_delta_old" ON "dbrdf_humanDevelopmentIndexAsOf_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_humanDevelopmentIndexAsOf_delta_old" ON "dbrdf_humanDevelopmentIndexAsOf_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_humanDevelopmentIndexAsOf_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 269
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtAlpg_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtAlpg_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_winsAtAlpg" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtAlpg_delta_old" ON "dbrdf_winsAtAlpg_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtAlpg_delta_old" ON "dbrdf_winsAtAlpg_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtAlpg_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 270
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_resolution_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_resolution_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_resolution" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_resolution_delta_old" ON "dbrdf_resolution_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_resolution_delta_old" ON "dbrdf_resolution_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_resolution_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 271
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_BullFighter"(s) SELECT DISTINCT t0.s FROM "dbrdf_BullFighter_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_BullFighter_delta_old";
        INSERT INTO "dbrdf_BullFighter_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_BullFighter_delta_new" t0;
        TRUNCATE TABLE "dbrdf_BullFighter_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 272
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtPGA_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtPGA_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_winsAtPGA" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtPGA_delta_old" ON "dbrdf_winsAtPGA_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtPGA_delta_old" ON "dbrdf_winsAtPGA_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtPGA_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 273
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_thirdDriver_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_thirdDriver_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_thirdDriver" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_thirdDriver_delta_old" ON "dbrdf_thirdDriver_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_thirdDriver_delta_old" ON "dbrdf_thirdDriver_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_thirdDriver_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 274
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_endPoint_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_endPoint_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_endPoint" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_endPoint_delta_old" ON "dbrdf_endPoint_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_endPoint_delta_old" ON "dbrdf_endPoint_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_endPoint_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 275
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_PrimeMinister"(s) SELECT DISTINCT t0.s FROM "dbrdf_PrimeMinister_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_PrimeMinister_delta_old";
        INSERT INTO "dbrdf_PrimeMinister_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_PrimeMinister_delta_new" t0;
        TRUNCATE TABLE "dbrdf_PrimeMinister_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 276
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumDischarge_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_maximumDischarge_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_maximumDischarge" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_maximumDischarge_delta_old" ON "dbrdf_maximumDischarge_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_maximumDischarge_delta_old" ON "dbrdf_maximumDischarge_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumDischarge_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 277
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_periapsis_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_periapsis_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_periapsis0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_periapsis_delta_old0" ON "dbrdf_periapsis_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_periapsis_delta_old0" ON "dbrdf_periapsis_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_periapsis_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_periapsis0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_periapsis_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_periapsis_delta_old0";
        INSERT INTO "dbrdf_periapsis_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_periapsis_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_periapsis_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 278
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfVisitors_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfVisitors_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfVisitors" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfVisitors_delta_old" ON "dbrdf_numberOfVisitors_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfVisitors_delta_old" ON "dbrdf_numberOfVisitors_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfVisitors_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 279
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 280
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_playerInTeam_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_playerInTeam_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_playerInTeam" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_playerInTeam_delta_old" ON "dbrdf_playerInTeam_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_playerInTeam_delta_old" ON "dbrdf_playerInTeam_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_playerInTeam_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 281
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_whaDraftYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_whaDraftYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_whaDraftYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_whaDraftYear_delta_old" ON "dbrdf_whaDraftYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_whaDraftYear_delta_old" ON "dbrdf_whaDraftYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_whaDraftYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 282
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_averageSpeed_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_averageSpeed_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_averageSpeed" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_averageSpeed_delta_old" ON "dbrdf_averageSpeed_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_averageSpeed_delta_old" ON "dbrdf_averageSpeed_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_averageSpeed_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 283
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_discontinued_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_discontinued_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_discontinued" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_discontinued_delta_old" ON "dbrdf_discontinued_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_discontinued_delta_old" ON "dbrdf_discontinued_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_discontinued_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 284
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_SoftballLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_SoftballLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SoftballLeague_delta_old";
        INSERT INTO "dbrdf_SoftballLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SoftballLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SoftballLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 285
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mascot_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mascot_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_mascot" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mascot_delta_old" ON "dbrdf_mascot_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mascot_delta_old" ON "dbrdf_mascot_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mascot_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 286
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_failedLaunches_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_failedLaunches_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_failedLaunches" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_failedLaunches_delta_old" ON "dbrdf_failedLaunches_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_failedLaunches_delta_old" ON "dbrdf_failedLaunches_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_failedLaunches_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 287
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfParticipatingNations_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfParticipatingNations_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfParticipatingNations" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfParticipatingNations_delta_old" ON "dbrdf_numberOfParticipatingNations_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfParticipatingNations_delta_old" ON "dbrdf_numberOfParticipatingNations_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfParticipatingNations_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 288
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_classis_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_classis_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_classis" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_classis_delta_old" ON "dbrdf_classis_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_classis_delta_old" ON "dbrdf_classis_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_classis_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 289
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_uRN_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_uRN_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_uRN" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_uRN_delta_old" ON "dbrdf_uRN_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_uRN_delta_old" ON "dbrdf_uRN_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_uRN_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 290
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_showJudge_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_showJudge_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_showJudge" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_showJudge_delta_old" ON "dbrdf_showJudge_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_showJudge_delta_old" ON "dbrdf_showJudge_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_showJudge_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 291
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_chiefEditor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_chiefEditor_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_chiefEditor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_chiefEditor_delta_old" ON "dbrdf_chiefEditor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_chiefEditor_delta_old" ON "dbrdf_chiefEditor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_chiefEditor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 292
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_BasketballLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_BasketballLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_BasketballLeague_delta_old";
        INSERT INTO "dbrdf_BasketballLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_BasketballLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_BasketballLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 293
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ceremonialCounty_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ceremonialCounty_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_ceremonialCounty" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ceremonialCounty_delta_old" ON "dbrdf_ceremonialCounty_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ceremonialCounty_delta_old" ON "dbrdf_ceremonialCounty_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ceremonialCounty_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 294
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 295
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_county_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_county_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_county" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_county_delta_old" ON "dbrdf_county_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_county_delta_old" ON "dbrdf_county_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_county_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 296
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_associate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_associate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_associate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_associate_delta_old" ON "dbrdf_associate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_associate_delta_old" ON "dbrdf_associate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_associate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 297
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_knownFor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_knownFor_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_knownFor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_knownFor_delta_old" ON "dbrdf_knownFor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_knownFor_delta_old" ON "dbrdf_knownFor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_knownFor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 298
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_closingFilm_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_closingFilm_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_closingFilm" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_closingFilm_delta_old" ON "dbrdf_closingFilm_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_closingFilm_delta_old" ON "dbrdf_closingFilm_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_closingFilm_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 299
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_atcSupplemental_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_atcSupplemental_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_atcSupplemental" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_atcSupplemental_delta_old" ON "dbrdf_atcSupplemental_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_atcSupplemental_delta_old" ON "dbrdf_atcSupplemental_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_atcSupplemental_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 300
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_subsidiary_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_subsidiary_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_subsidiary" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_subsidiary_delta_old" ON "dbrdf_subsidiary_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_subsidiary_delta_old" ON "dbrdf_subsidiary_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_subsidiary_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 301
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_careerPoints_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_careerPoints_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_careerPoints" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_careerPoints_delta_old" ON "dbrdf_careerPoints_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_careerPoints_delta_old" ON "dbrdf_careerPoints_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_careerPoints_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 302
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_filmFareAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_filmFareAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_filmFareAward" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_filmFareAward_delta_old" ON "dbrdf_filmFareAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_filmFareAward_delta_old" ON "dbrdf_filmFareAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_filmFareAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/filmFareAward$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/filmFareAward$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_filmFareAward_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_filmFareAward_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_filmFareAward" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_filmFareAward" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_filmFareAward"(s, o) SELECT DISTINCT t0.s, 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 "dbrdf_branchFrom" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_branchFrom" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_branchFrom" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_branchFrom"(s, o) SELECT DISTINCT t0.s, 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 "dbrdf_Lieutenant" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Lieutenant_delta_old" ON "dbrdf_Lieutenant_delta_old"(s);
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Lieutenant" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Lieutenant"(s) SELECT DISTINCT t0.s 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 "dbrdf_sourceRegion" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_sourceRegion" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_sourceRegion" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_sourceRegion"(s, o) SELECT DISTINCT t0.s, 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 "dbrdf_politicalPartyInLegislature" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_politicalPartyInLegislature" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_politicalPartyInLegislature" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_politicalPartyInLegislature"(s, o) SELECT DISTINCT t0.s, 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 "dbrdf_company" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_company_delta_old" ON "dbrdf_company_delta_old"(s, 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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_company" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_company" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_company"(s, o) SELECT DISTINCT t0.s, 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 "dbrdf_lastAirDate" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_lastAirDate" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_lastAirDate" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_lastAirDate"(s, o) SELECT DISTINCT t0.s, 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 "dbrdf_locationCity" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_locationCity" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_locationCity" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_locationCity"(s, o) SELECT DISTINCT t0.s, 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 "dbrdf_filmPolskiId" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_filmPolskiId" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_filmPolskiId" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_filmPolskiId"(s, o) SELECT DISTINCT t0.s, 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 "dbrdf_lastFlightStartDate" t0;
    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) .
