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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 132
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_synonym_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_synonym_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26614;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_synonym_delta_old" ON "dbrdf_synonym_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_synonym_delta_old" ON "dbrdf_synonym_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_synonym_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 133
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_colourHexCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_colourHexCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26615;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_colourHexCode_delta_old" ON "dbrdf_colourHexCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_colourHexCode_delta_old" ON "dbrdf_colourHexCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_colourHexCode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 134
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_volume_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_volume_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26616;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_volume_delta_old0" ON "dbrdf_volume_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_volume_delta_old0" ON "dbrdf_volume_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_volume_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/SpaceStation/volume$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/SpaceStation/volume$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_volume_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_volume_delta_old0" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26616 AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26616, t0.o FROM "dbrdf_volume_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_volume_delta_old0";
        INSERT INTO "dbrdf_volume_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_volume_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_volume_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 135
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 136
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_governmentCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_governmentCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26618;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_governmentCountry_delta_old" ON "dbrdf_governmentCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_governmentCountry_delta_old" ON "dbrdf_governmentCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_governmentCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26618, t0.o FROM "dbrdf_governmentCountry_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_governmentCountry_delta_old";
        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 "__triples" t0 WHERE t0.p = 26619;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26619 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26619 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26619, 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 "__triples" t0 WHERE t0.p = 26620;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26620 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26620 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26620, 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 "__triples" t0 WHERE t0.p = 26621;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26621 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26621 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26621, 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26622;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26622);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26622 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 "__triples" t0 WHERE t0.p = 26623;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26623 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26623 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26623, 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 "__triples" t0 WHERE t0.p = 26624;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26624 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26624 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26624, 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 "__triples" t0 WHERE t0.p = 26625;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26625 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26625 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26625, 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 "__triples" t0 WHERE t0.p = 26626;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26626 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26626 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26626, 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 "__triples" t0 WHERE t0.p = 26627;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26627 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26627 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26627, 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26628;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26628);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26628 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 "__triples" t0 WHERE t0.p = 26629;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26629 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26629 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26629, 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 "__triples" t0 WHERE t0.p = 26630;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26630 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26630 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26630, 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 "__triples" t0 WHERE t0.p = 26631;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26631 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26631 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26631, 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 "__triples" t0 WHERE t0.p = 26632;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26632 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26632 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26632, 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 "__triples" t0 WHERE t0.p = 26633;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26633 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26633 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26633, 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 "__triples" t0 WHERE t0.p = 26634;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26634 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26634 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26634, 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 "__triples" t0 WHERE t0.p = 26635;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26635 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26635 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26635, 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26636;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26636);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26636 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 "__triples" t0 WHERE t0.p = 26637;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26637 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26637 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26637, 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 "__triples" t0 WHERE t0.p = 26638;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26638 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26638 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26638, 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 "__triples" t0 WHERE t0.p = 26639;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26639 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26639 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26639, 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 "__triples" t0 WHERE t0.p = 26640;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26640 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26640 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26640, 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26641;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26641);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26641 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 "__triples" t0 WHERE t0.p = 26642;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26642 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26642 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26642, 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 "__triples" t0 WHERE t0.p = 26643;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26643 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26643 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26643, 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_rankingWins_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rankingWins_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26644;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26644 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26644 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26644, 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 163
    ---- 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 "__triples" t0 WHERE t0.p = 26645;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26645 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26645 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26645, 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 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 "__triples" t0 WHERE t0.p = 26646;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26646 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26646 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26646, 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 "__triples" t0 WHERE t0.p = 26647;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26647 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26647 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26647, 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26648;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26648);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26648 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 "__triples" t0 WHERE t0.p = 26649;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26649 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26649 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26649, 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 "__triples" t0 WHERE t0.p = 26650;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26650 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26650 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26650, 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 "__triples" t0 WHERE t0.p = 26651;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26651 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26651 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26651, 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 "__triples" t0 WHERE t0.p = 26652;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26652 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26652 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26652, 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 "__triples" t0 WHERE t0.p = 26653;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26653 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26653 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26653, 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26654;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26654);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26654 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 "__triples" t0 WHERE t0.p = 26655;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26655 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26655 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26655, 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 "__triples" t0 WHERE t0.p = 26656;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26656 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26656 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26656, 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 "__triples" t0 WHERE t0.p = 26657;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26657 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26657 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26657, 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 "__triples" t0 WHERE t0.p = 26658;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26658 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26658 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26658, 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 "__triples" t0 WHERE t0.p = 26659;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26659 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26659 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26659, 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 "__triples" t0 WHERE t0.p = 26660;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26660 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26660 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26660, 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 "__triples" t0 WHERE t0.p = 26661;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26661 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26661 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26661, 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 "__triples" t0 WHERE t0.p = 26662;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26662 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26662 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26662, 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 "__triples" t0 WHERE t0.p = 26663;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26663 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26663 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26663, 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 "__triples" t0 WHERE t0.p = 26664;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26664 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26664 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26664, 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 "__triples" t0 WHERE t0.p = 26665;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26665 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26665 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26665, 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 "__triples" t0 WHERE t0.p = 26666;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26666 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26666 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26666, 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 "__triples" t0 WHERE t0.p = 26667;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26667 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26667 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26667, 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 "__triples" t0 WHERE t0.p = 26668;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26668 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26668 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26668, 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 "__triples" t0 WHERE t0.p = 26669;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26669 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26669 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26669, 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 "__triples" t0 WHERE t0.p = 26670;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26670 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26670 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26670, 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26671;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26671);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26671 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 "__triples" t0 WHERE t0.p = 26672;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26672 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26672 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26672, 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 "__triples" t0 WHERE t0.p = 26673;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26673 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26673 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26673, 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 "__triples" t0 WHERE t0.p = 26674;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26674 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26674 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26674, 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26675;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26675);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26675 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 "__triples" t0 WHERE t0.p = 26676;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26676 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26676 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26676, 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 "__triples" t0 WHERE t0.p = 26677;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26677 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26677 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26677, 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26678;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26678);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26678 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 "__triples" t0 WHERE t0.p = 26679;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26679 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26679 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26679, 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 "__triples" t0 WHERE t0.p = 26680;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26680 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26680 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26680, 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 "__triples" t0 WHERE t0.p = 26681;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26681 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26681 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26681, 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 "__triples" t0 WHERE t0.p = 26682;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26682 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26682 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26682, 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 "__triples" t0 WHERE t0.p = 26683;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26683 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26683 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26683, 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 "__triples" t0 WHERE t0.p = 26684;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26684 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26684 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26684, 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 "__triples" t0 WHERE t0.p = 26685;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26685 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26685 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26685, 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 "__triples" t0 WHERE t0.p = 26686;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26686 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26686 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26686, 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 "__triples" t0 WHERE t0.p = 26687;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26687 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26687 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26687, 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 "__triples" t0 WHERE t0.p = 26688;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26688 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26688 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26688, 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 "__triples" t0 WHERE t0.p = 26689;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26689 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26689 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26689, 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26690;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26690);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26690 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 "__triples" t0 WHERE t0.p = 26691;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26691 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26691 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26691, 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 "__triples" t0 WHERE t0.p = 26692;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26692 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26692 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26692, 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 "__triples" t0 WHERE t0.p = 26693;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26693 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26693 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26693, 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 "__triples" t0 WHERE t0.p = 26694;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26694 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26694 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26694, 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 "__triples" t0 WHERE t0.p = 26695;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26695 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26695 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26695, 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 "__triples" t0 WHERE t0.p = 26696;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26696 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26696 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26696, 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 "__triples" t0 WHERE t0.p = 26697;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26697 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26697 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26697, 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 "__triples" t0 WHERE t0.p = 26698;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26698 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26698 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26698, 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 "__triples" t0 WHERE t0.p = 26699;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26699 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26699 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26699, 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 "__triples" t0 WHERE t0.p = 26700;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26700 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26700 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26700, 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 "__triples" t0 WHERE t0.p = 26701;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26701 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26701 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26701, 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 "__triples" t0 WHERE t0.p = 26702;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26702 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26702 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26702, 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 "__triples" t0 WHERE t0.p = 26703;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26703 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26703 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26703, 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 "__triples" t0 WHERE t0.p = 26704;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26704 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26704 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26704, 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 "__triples" t0 WHERE t0.p = 26705;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26705 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26705 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26705, 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 "__triples" t0 WHERE t0.p = 26706;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26706 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26706 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26706, 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 "__triples" t0 WHERE t0.p = 26707;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26707 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26707 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26707, 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 "__triples" t0 WHERE t0.p = 26708;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26708 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26708 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26708, 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 "__triples" t0 WHERE t0.p = 26709;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26709 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26709 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26709, 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 "__triples" t0 WHERE t0.p = 26710;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26710 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26710 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26710, 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 "__triples" t0 WHERE t0.p = 26711;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26711 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26711 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26711, 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 "__triples" t0 WHERE t0.p = 26712;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26712 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26712 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26712, 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 "__triples" t0 WHERE t0.p = 26713;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26713 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26713 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26713, 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 "__triples" t0 WHERE t0.p = 26714;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26714 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26714 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26714, 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 "__triples" t0 WHERE t0.p = 26715;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26715 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26715 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26715, 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 "__triples" t0 WHERE t0.p = 26716;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26716 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26716 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26716, 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 "__triples" t0 WHERE t0.p = 26717;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26717 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26717 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26717, 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 "__triples" t0 WHERE t0.p = 26718;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26718 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26718 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26718, 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_assistantPrincipal_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_assistantPrincipal_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26719;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26719 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26719 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26719, 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 238
    ---- 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 "__triples" t0 WHERE t0.p = 26720;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26720 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26720 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26720, 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 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 "__triples" t0 WHERE t0.p = 26721;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26721 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26721 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26721, 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 "__triples" t0 WHERE t0.p = 26722;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26722 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26722 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26722, 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26723 FROM "__triples" t0 WHERE t0.p = 26722 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26723);
    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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26723;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26723);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26723 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26724;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26724);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26724 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 "__triples" t0 WHERE t0.p = 26725;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26725 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26725 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26725, 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 "__triples" t0 WHERE t0.p = 26726;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26726 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26726 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26726, 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26727;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26727);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26727 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 "__triples" t0 WHERE t0.p = 26728;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26728 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26728 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26728, 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 "__triples" t0 WHERE t0.p = 26729;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26729 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26729 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26729, 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 "__triples" t0 WHERE t0.p = 26730;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26730 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26730 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26730, 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 "__triples" t0 WHERE t0.p = 26731;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26731 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26731 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26731, 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 "__triples" t0 WHERE t0.p = 26732;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26732 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26732 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26732, 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 "__triples" t0 WHERE t0.p = 26733;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26733 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26733 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26733, 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 "__triples" t0 WHERE t0.p = 26734;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26734 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26734 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26734, 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26735;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26735);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26735 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 "__triples" t0 WHERE t0.p = 26736;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26736 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26736 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26736, 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 "__triples" t0 WHERE t0.p = 26737;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26737 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26737 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26737, 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 "__triples" t0 WHERE t0.p = 26738;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26738 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26738 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26738, 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 "__triples" t0 WHERE t0.p = 26739;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26739 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26739 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26739, 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 "__triples" t0 WHERE t0.p = 26740;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26740 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26740 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26740, 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 "__triples" t0 WHERE t0.p = 26741;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26741 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26741 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26741, 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 "__triples" t0 WHERE t0.p = 26742;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26742 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26742 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26742, 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 "__triples" t0 WHERE t0.p = 26743;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26743 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26743 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26743, 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 "__triples" t0 WHERE t0.p = 26744;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26744 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26744 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26744, 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 "__triples" t0 WHERE t0.p = 26745;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26745 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26745 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26745, 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 "__triples" t0 WHERE t0.p = 26746;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26746 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26746 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26746, 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 "__triples" t0 WHERE t0.p = 26747;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26747 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26747 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26747, 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 "__triples" t0 WHERE t0.p = 26748;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26748 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26748 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26748, 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 "__triples" t0 WHERE t0.p = 26749;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26749 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26749 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26749, 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_winsAtAlpg_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtAlpg_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26750;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26750 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26750 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26750, 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 269
    ---- 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 "__triples" t0 WHERE t0.p = 26751;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26751 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26751 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26751, 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 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 "__triples" t0 WHERE t0.p = 26752;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26752 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26752 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26752, 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26753;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26753);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26753 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 "__triples" t0 WHERE t0.p = 26754;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26754 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26754 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26754, 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 "__triples" t0 WHERE t0.p = 26755;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26755 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26755 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26755, 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 "__triples" t0 WHERE t0.p = 26756;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26756 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26756 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26756, 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26757;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26757);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26757 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 "__triples" t0 WHERE t0.p = 26758;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26758 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26758 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26758, 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 "__triples" t0 WHERE t0.p = 26759;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26759 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26759 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26759, 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 "__triples" t0 WHERE t0.p = 26760;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26760 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26760 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26760, 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 "__triples" t0 WHERE t0.p = 26761;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26761 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26761 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26761, 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 "__triples" t0 WHERE t0.p = 26762;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26762 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26762 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26762, 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 "__triples" t0 WHERE t0.p = 26763;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26763 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26763 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26763, 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 "__triples" t0 WHERE t0.p = 26764;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26764 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26764 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26764, 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 "__triples" t0 WHERE t0.p = 26765;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26765 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26765 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26765, 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26766;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26766);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26766 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 "__triples" t0 WHERE t0.p = 26767;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26767 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26767 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26767, 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 "__triples" t0 WHERE t0.p = 26768;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26768 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26768 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26768, 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 "__triples" t0 WHERE t0.p = 26769;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26769 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26769 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26769, 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 "__triples" t0 WHERE t0.p = 26770;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26770 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26770 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26770, 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 "__triples" t0 WHERE t0.p = 26771;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26771 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26771 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26771, 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 "__triples" t0 WHERE t0.p = 26772;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26772 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26772 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26772, 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 "__triples" t0 WHERE t0.p = 26773;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26773 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26773 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26773, 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26774;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26774);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26774 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 "__triples" t0 WHERE t0.p = 26775;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26775 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26775 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26775, 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 "__triples" t0 WHERE t0.p = 26776;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26776 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26776 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26776, 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 "__triples" t0 WHERE t0.p = 26777;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26777 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26777 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26777, 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 "__triples" t0 WHERE t0.p = 26778;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26778 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26778 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26778, 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 "__triples" t0 WHERE t0.p = 26779;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26779 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26779 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26779, 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_atcSupplemental_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_atcSupplemental_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26780;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26780 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26780 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26780, 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 299
    ---- 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 "__triples" t0 WHERE t0.p = 26781;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26781 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26781 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26781, 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 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 "__triples" t0 WHERE t0.p = 26782;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26782 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26782 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26782, 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 "__triples" t0 WHERE t0.p = 26783;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26783 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26783 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26783, 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 "__triples" t0 WHERE t0.p = 26784;
    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) .
