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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Ambassador$delta_new>(?Y) :- <http://dbpedia.org/ontology/Ambassador$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Ambassador_delta_new"(s) SELECT t1.o FROM "dbrdf_Ambassador_delta_old" t0, "__triples" t1 WHERE 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 = 26955);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 474
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 475
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 476
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 477
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/ChemicalElement$delta_new>(?Y) :- <http://dbpedia.org/ontology/ChemicalElement$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_ChemicalElement_delta_new"(s) SELECT t1.o FROM "dbrdf_ChemicalElement_delta_old" t0, "__triples" t1 WHERE 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 = 26959);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 478
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 479
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 480
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 481
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 482
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 483
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 484
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 485
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_boilingPoint_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_boilingPoint_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26967;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_boilingPoint_delta_old0" ON "dbrdf_boilingPoint_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_boilingPoint_delta_old0" ON "dbrdf_boilingPoint_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_boilingPoint_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/Drug/boilingPoint$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Drug/boilingPoint$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_boilingPoint_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_boilingPoint_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 = 26967 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/Drug/boilingPoint$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/Drug/boilingPoint$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_boilingPoint_delta_new0"(s, o) SELECT t0.s, t1.o FROM "dbrdf_boilingPoint_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 = 26967 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26967, t0.o FROM "dbrdf_boilingPoint_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_boilingPoint_delta_old0";
        INSERT INTO "dbrdf_boilingPoint_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_boilingPoint_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_boilingPoint_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 486
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 487
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 488
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 489
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 490
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 491
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 492
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 493
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 494
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 495
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 496
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 497
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 498
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 499
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_missionDuration_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_missionDuration_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26981;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_missionDuration_delta_old" ON "dbrdf_missionDuration_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_missionDuration_delta_old" ON "dbrdf_missionDuration_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_missionDuration_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 500
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 501
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 502
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/SoccerClubSeason$delta_new>(?Y) :- <http://dbpedia.org/ontology/SoccerClubSeason$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_SoccerClubSeason_delta_new"(s) SELECT t1.o FROM "dbrdf_SoccerClubSeason_delta_old" t0, "__triples" t1 WHERE 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 = 26984);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 503
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 504
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 505
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 506
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 507
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 508
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 509
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 510
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 511
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 512
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_height_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_height_delta_old1"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26994;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_height_delta_old1" ON "dbrdf_height_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_height_delta_old1" ON "dbrdf_height_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_height_delta_new1"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 513
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_logo_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_logo_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26995;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_logo_delta_old" ON "dbrdf_logo_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_logo_delta_old" ON "dbrdf_logo_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_logo_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 514
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_utcOffset_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_utcOffset_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26996;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_utcOffset_delta_old" ON "dbrdf_utcOffset_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_utcOffset_delta_old" ON "dbrdf_utcOffset_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_utcOffset_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 515
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_width_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_width_delta_old1"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26997;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_width_delta_old1" ON "dbrdf_width_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_width_delta_old1" ON "dbrdf_width_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_width_delta_new1"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 516
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_illiteracy_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_illiteracy_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26998;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_illiteracy_delta_old" ON "dbrdf_illiteracy_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_illiteracy_delta_old" ON "dbrdf_illiteracy_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_illiteracy_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 517
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_coProducer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_coProducer_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26999;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_coProducer_delta_old" ON "dbrdf_coProducer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_coProducer_delta_old" ON "dbrdf_coProducer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_coProducer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 518
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_unitedStatesNationalBridgeId_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_unitedStatesNationalBridgeId_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27000;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_unitedStatesNationalBridgeId_delta_old" ON "dbrdf_unitedStatesNationalBridgeId_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_unitedStatesNationalBridgeId_delta_old" ON "dbrdf_unitedStatesNationalBridgeId_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_unitedStatesNationalBridgeId_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 519
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 520
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Decoration_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Decoration_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27002;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Decoration_delta_old" ON "dbrdf_Decoration_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Decoration_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/Decoration$delta_new>(?Y) :- <http://dbpedia.org/ontology/Decoration$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Decoration_delta_new"(s) SELECT t1.o FROM "dbrdf_Decoration_delta_old" t0, "__triples" t1 WHERE 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 = 27002);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 521
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_abbreviation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_abbreviation_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27003;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_abbreviation_delta_old" ON "dbrdf_abbreviation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_abbreviation_delta_old" ON "dbrdf_abbreviation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_abbreviation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 522
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_smallestCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_smallestCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27004;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_smallestCountry_delta_old" ON "dbrdf_smallestCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_smallestCountry_delta_old" ON "dbrdf_smallestCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_smallestCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 523
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_highestState_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_highestState_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27005;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_highestState_delta_old" ON "dbrdf_highestState_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_highestState_delta_old" ON "dbrdf_highestState_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_highestState_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 524
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lcc_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lcc_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27006;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lcc_delta_old" ON "dbrdf_lcc_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lcc_delta_old" ON "dbrdf_lcc_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lcc_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 525
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winterTemperature_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winterTemperature_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27007;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winterTemperature_delta_old" ON "dbrdf_winterTemperature_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winterTemperature_delta_old" ON "dbrdf_winterTemperature_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winterTemperature_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 526
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rating_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rating_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27008;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rating_delta_old" ON "dbrdf_rating_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rating_delta_old" ON "dbrdf_rating_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rating_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 527
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_status_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_status_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27009;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_status_delta_old" ON "dbrdf_status_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_status_delta_old" ON "dbrdf_status_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_status_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 528
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_piercing_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_piercing_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27010;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_piercing_delta_old" ON "dbrdf_piercing_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_piercing_delta_old" ON "dbrdf_piercing_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_piercing_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 529
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_refseq_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_refseq_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27011;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_refseq_delta_old" ON "dbrdf_refseq_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_refseq_delta_old" ON "dbrdf_refseq_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_refseq_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 530
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_endowment_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_endowment_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27012;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_endowment_delta_old" ON "dbrdf_endowment_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_endowment_delta_old" ON "dbrdf_endowment_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_endowment_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 531
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_kingdom_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_kingdom_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27013;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_kingdom_delta_old" ON "dbrdf_kingdom_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_kingdom_delta_old" ON "dbrdf_kingdom_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_kingdom_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 532
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_parish_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_parish_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27014;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_parish_delta_old" ON "dbrdf_parish_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_parish_delta_old" ON "dbrdf_parish_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_parish_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 533
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationRuralDensity_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_populationRuralDensity_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27015;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_populationRuralDensity_delta_old" ON "dbrdf_populationRuralDensity_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_populationRuralDensity_delta_old" ON "dbrdf_populationRuralDensity_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationRuralDensity_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 534
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_reopeningDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_reopeningDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27016;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_reopeningDate_delta_old" ON "dbrdf_reopeningDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_reopeningDate_delta_old" ON "dbrdf_reopeningDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_reopeningDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 535
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_currentRecord_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_currentRecord_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27017;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_currentRecord_delta_old" ON "dbrdf_currentRecord_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_currentRecord_delta_old" ON "dbrdf_currentRecord_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_currentRecord_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 536
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_assetUnderManagement_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_assetUnderManagement_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27018;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_assetUnderManagement_delta_old" ON "dbrdf_assetUnderManagement_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_assetUnderManagement_delta_old" ON "dbrdf_assetUnderManagement_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_assetUnderManagement_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 537
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_AmericanFootballPlayer_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_AmericanFootballPlayer_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27019;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_AmericanFootballPlayer_delta_old" ON "dbrdf_AmericanFootballPlayer_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_AmericanFootballPlayer_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/AmericanFootballPlayer$delta_new>(?Y) :- <http://dbpedia.org/ontology/AmericanFootballPlayer$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_AmericanFootballPlayer_delta_new"(s) SELECT t1.o FROM "dbrdf_AmericanFootballPlayer_delta_old" t0, "__triples" t1 WHERE 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 = 27019);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 538
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Cycad_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Cycad_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27020;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Cycad_delta_old" ON "dbrdf_Cycad_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Cycad_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/Cycad$delta_new>(?Y) :- <http://dbpedia.org/ontology/Cycad$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Cycad_delta_new"(s) SELECT t1.o FROM "dbrdf_Cycad_delta_old" t0, "__triples" t1 WHERE 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 = 27020);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 539
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cylinderCount_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cylinderCount_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27021;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cylinderCount_delta_old" ON "dbrdf_cylinderCount_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_cylinderCount_delta_old" ON "dbrdf_cylinderCount_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cylinderCount_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 540
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_conservationStatusSystem_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_conservationStatusSystem_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27022;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_conservationStatusSystem_delta_old" ON "dbrdf_conservationStatusSystem_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_conservationStatusSystem_delta_old" ON "dbrdf_conservationStatusSystem_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_conservationStatusSystem_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 541
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_highwaySystem_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_highwaySystem_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27023;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_highwaySystem_delta_old" ON "dbrdf_highwaySystem_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_highwaySystem_delta_old" ON "dbrdf_highwaySystem_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_highwaySystem_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 542
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_note_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_note_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27024;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_note_delta_old" ON "dbrdf_note_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_note_delta_old" ON "dbrdf_note_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_note_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 543
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectBudgetFunding_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_projectBudgetFunding_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27025;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_projectBudgetFunding_delta_old" ON "dbrdf_projectBudgetFunding_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_projectBudgetFunding_delta_old" ON "dbrdf_projectBudgetFunding_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectBudgetFunding_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 544
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 545
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_apoapsis_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_apoapsis_delta_old1"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27027;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_apoapsis_delta_old1" ON "dbrdf_apoapsis_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_apoapsis_delta_old1" ON "dbrdf_apoapsis_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_apoapsis_delta_new1"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 546
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_upperAge_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_upperAge_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27028;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_upperAge_delta_old" ON "dbrdf_upperAge_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_upperAge_delta_old" ON "dbrdf_upperAge_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_upperAge_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 547
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_filmColourType_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_filmColourType_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27029;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_filmColourType_delta_old" ON "dbrdf_filmColourType_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_filmColourType_delta_old" ON "dbrdf_filmColourType_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_filmColourType_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 548
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_governingBody_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_governingBody_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27030;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_governingBody_delta_old" ON "dbrdf_governingBody_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_governingBody_delta_old" ON "dbrdf_governingBody_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_governingBody_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 549
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Bacteria_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Bacteria_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27031;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Bacteria_delta_old" ON "dbrdf_Bacteria_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Bacteria_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/Bacteria$delta_new>(?Y) :- <http://dbpedia.org/ontology/Bacteria$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Bacteria_delta_new"(s) SELECT t1.o FROM "dbrdf_Bacteria_delta_old" t0, "__triples" t1 WHERE 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 = 27031);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 550
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_AmericanFootballLeague_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_AmericanFootballLeague_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27032;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_AmericanFootballLeague_delta_old" ON "dbrdf_AmericanFootballLeague_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_AmericanFootballLeague_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/AmericanFootballLeague$delta_new>(?Y) :- <http://dbpedia.org/ontology/AmericanFootballLeague$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_AmericanFootballLeague_delta_new"(s) SELECT t1.o FROM "dbrdf_AmericanFootballLeague_delta_old" t0, "__triples" t1 WHERE 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 = 27032);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 551
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_collection_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_collection_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27033;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_collection_delta_old" ON "dbrdf_collection_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_collection_delta_old" ON "dbrdf_collection_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_collection_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 552
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rightAscension_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rightAscension_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27034;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rightAscension_delta_old" ON "dbrdf_rightAscension_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rightAscension_delta_old" ON "dbrdf_rightAscension_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rightAscension_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 553
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_launches_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_launches_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27035;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_launches_delta_old" ON "dbrdf_launches_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_launches_delta_old" ON "dbrdf_launches_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_launches_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 554
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_stateOfOrigin_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_stateOfOrigin_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27036;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_stateOfOrigin_delta_old" ON "dbrdf_stateOfOrigin_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_stateOfOrigin_delta_old" ON "dbrdf_stateOfOrigin_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_stateOfOrigin_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 555
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_crewSize_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_crewSize_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27037;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_crewSize_delta_old" ON "dbrdf_crewSize_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_crewSize_delta_old" ON "dbrdf_crewSize_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_crewSize_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 556
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_employer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_employer_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27038;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_employer_delta_old" ON "dbrdf_employer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_employer_delta_old" ON "dbrdf_employer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_employer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 557
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_compiler_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_compiler_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27039;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_compiler_delta_old" ON "dbrdf_compiler_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_compiler_delta_old" ON "dbrdf_compiler_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_compiler_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 558
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_principal_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_principal_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27040;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_principal_delta_old" ON "dbrdf_principal_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_principal_delta_old" ON "dbrdf_principal_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_principal_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 559
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_minimumDischarge_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_minimumDischarge_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27041;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_minimumDischarge_delta_old" ON "dbrdf_minimumDischarge_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_minimumDischarge_delta_old" ON "dbrdf_minimumDischarge_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_minimumDischarge_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 560
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rgbCoordinateGreen_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rgbCoordinateGreen_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27042;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rgbCoordinateGreen_delta_old" ON "dbrdf_rgbCoordinateGreen_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rgbCoordinateGreen_delta_old" ON "dbrdf_rgbCoordinateGreen_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rgbCoordinateGreen_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 561
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_shoreLength_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_shoreLength_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27043;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_shoreLength_delta_old" ON "dbrdf_shoreLength_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_shoreLength_delta_old" ON "dbrdf_shoreLength_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_shoreLength_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 562
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sourceCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27044;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sourceCountry_delta_old" ON "dbrdf_sourceCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sourceCountry_delta_old" ON "dbrdf_sourceCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 563
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_shuttle_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_shuttle_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27045;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_shuttle_delta_old" ON "dbrdf_shuttle_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_shuttle_delta_old" ON "dbrdf_shuttle_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_shuttle_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 564
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_fastestDriverTeam_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_fastestDriverTeam_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27046;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_fastestDriverTeam_delta_old" ON "dbrdf_fastestDriverTeam_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_fastestDriverTeam_delta_old" ON "dbrdf_fastestDriverTeam_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_fastestDriverTeam_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 565
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_routeDirection_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_routeDirection_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27047;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_routeDirection_delta_old" ON "dbrdf_routeDirection_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_routeDirection_delta_old" ON "dbrdf_routeDirection_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_routeDirection_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 566
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_recordLabel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_recordLabel_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27048;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_recordLabel_delta_old" ON "dbrdf_recordLabel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_recordLabel_delta_old" ON "dbrdf_recordLabel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_recordLabel_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 567
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastRace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lastRace_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27049;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lastRace_delta_old" ON "dbrdf_lastRace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lastRace_delta_old" ON "dbrdf_lastRace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastRace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 568
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_afdbId_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_afdbId_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27050;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_afdbId_delta_old" ON "dbrdf_afdbId_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_afdbId_delta_old" ON "dbrdf_afdbId_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_afdbId_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 569
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_spouse_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_spouse_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27051;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_spouse_delta_old" ON "dbrdf_spouse_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_spouse_delta_old" ON "dbrdf_spouse_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_spouse_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 570
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_orbitalPeriod_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_orbitalPeriod_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27052;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_orbitalPeriod_delta_old0" ON "dbrdf_orbitalPeriod_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_orbitalPeriod_delta_old0" ON "dbrdf_orbitalPeriod_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_orbitalPeriod_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Galaxy/orbitalPeriod$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Galaxy/orbitalPeriod$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_orbitalPeriod_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_orbitalPeriod_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 = 27052 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/Galaxy/orbitalPeriod$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/Galaxy/orbitalPeriod$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_orbitalPeriod_delta_new0"(s, o) SELECT t0.s, t1.o FROM "dbrdf_orbitalPeriod_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 = 27052 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27052, t0.o FROM "dbrdf_orbitalPeriod_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_orbitalPeriod_delta_old0";
        INSERT INTO "dbrdf_orbitalPeriod_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_orbitalPeriod_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_orbitalPeriod_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 571
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_leftChild_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_leftChild_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27053;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_leftChild_delta_old" ON "dbrdf_leftChild_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_leftChild_delta_old" ON "dbrdf_leftChild_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_leftChild_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 572
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dateAct_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dateAct_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27054;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dateAct_delta_old" ON "dbrdf_dateAct_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dateAct_delta_old" ON "dbrdf_dateAct_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dateAct_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 573
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_month_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_month_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27055;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_month_delta_old" ON "dbrdf_month_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_month_delta_old" ON "dbrdf_month_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_month_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 574
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_introductionDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_introductionDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27056;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_introductionDate_delta_old" ON "dbrdf_introductionDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_introductionDate_delta_old" ON "dbrdf_introductionDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_introductionDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 575
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_foundationPlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_foundationPlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27057;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_foundationPlace_delta_old" ON "dbrdf_foundationPlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_foundationPlace_delta_old" ON "dbrdf_foundationPlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_foundationPlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 576
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_overallRecord_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_overallRecord_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27058;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_overallRecord_delta_old" ON "dbrdf_overallRecord_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_overallRecord_delta_old" ON "dbrdf_overallRecord_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_overallRecord_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 577
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_child_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_child_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27059;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_child_delta_old" ON "dbrdf_child_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_child_delta_old" ON "dbrdf_child_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_child_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 578
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_elementAbove_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_elementAbove_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27060;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_elementAbove_delta_old" ON "dbrdf_elementAbove_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_elementAbove_delta_old" ON "dbrdf_elementAbove_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_elementAbove_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 579
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mouthElevation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mouthElevation_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27061;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mouthElevation_delta_old" ON "dbrdf_mouthElevation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mouthElevation_delta_old" ON "dbrdf_mouthElevation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mouthElevation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 580
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_capitalPlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_capitalPlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27062;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_capitalPlace_delta_old" ON "dbrdf_capitalPlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_capitalPlace_delta_old" ON "dbrdf_capitalPlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_capitalPlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 581
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_demonym_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_demonym_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27063;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_demonym_delta_old" ON "dbrdf_demonym_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_demonym_delta_old" ON "dbrdf_demonym_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_demonym_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 582
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_alias_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_alias_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27064;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_alias_delta_old" ON "dbrdf_alias_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_alias_delta_old" ON "dbrdf_alias_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_alias_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 583
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_anniversary_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_anniversary_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27065;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_anniversary_delta_old" ON "dbrdf_anniversary_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_anniversary_delta_old" ON "dbrdf_anniversary_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_anniversary_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 584
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ceo_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ceo_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27066;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ceo_delta_old" ON "dbrdf_ceo_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ceo_delta_old" ON "dbrdf_ceo_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ceo_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 585
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_bloodType_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_bloodType_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27067;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_bloodType_delta_old" ON "dbrdf_bloodType_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_bloodType_delta_old" ON "dbrdf_bloodType_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_bloodType_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 586
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_giniCoefficientAsOf_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_giniCoefficientAsOf_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27068;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_giniCoefficientAsOf_delta_old" ON "dbrdf_giniCoefficientAsOf_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_giniCoefficientAsOf_delta_old" ON "dbrdf_giniCoefficientAsOf_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_giniCoefficientAsOf_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 587
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_playingTime_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_playingTime_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27069;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_playingTime_delta_old" ON "dbrdf_playingTime_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_playingTime_delta_old" ON "dbrdf_playingTime_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_playingTime_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 588
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_patron_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_patron_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27070;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_patron_delta_old" ON "dbrdf_patron_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_patron_delta_old" ON "dbrdf_patron_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_patron_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 589
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_coachedTeam_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_coachedTeam_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27071;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_coachedTeam_delta_old" ON "dbrdf_coachedTeam_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_coachedTeam_delta_old" ON "dbrdf_coachedTeam_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_coachedTeam_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 590
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_foundingPerson_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_foundingPerson_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27072;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_foundingPerson_delta_old" ON "dbrdf_foundingPerson_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_foundingPerson_delta_old" ON "dbrdf_foundingPerson_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_foundingPerson_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 591
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_locationCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_locationCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27073;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_locationCountry_delta_old" ON "dbrdf_locationCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_locationCountry_delta_old" ON "dbrdf_locationCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_locationCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 592
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lineLength_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lineLength_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27074;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lineLength_delta_old" ON "dbrdf_lineLength_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lineLength_delta_old" ON "dbrdf_lineLength_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lineLength_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 593
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ClubMoss_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ClubMoss_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27075;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ClubMoss_delta_old" ON "dbrdf_ClubMoss_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ClubMoss_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/ClubMoss$delta_new>(?Y) :- <http://dbpedia.org/ontology/ClubMoss$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_ClubMoss_delta_new"(s) SELECT t1.o FROM "dbrdf_ClubMoss_delta_old" t0, "__triples" t1 WHERE 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 = 27075);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 594
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_translator_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_translator_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27076;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_translator_delta_old" ON "dbrdf_translator_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_translator_delta_old" ON "dbrdf_translator_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_translator_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 595
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_meanTemperature_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_meanTemperature_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27077;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_meanTemperature_delta_old0" ON "dbrdf_meanTemperature_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_meanTemperature_delta_old0" ON "dbrdf_meanTemperature_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_meanTemperature_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Planet/meanTemperature$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Planet/meanTemperature$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_meanTemperature_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_meanTemperature_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 = 27077 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/Planet/meanTemperature$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/Planet/meanTemperature$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_meanTemperature_delta_new0"(s, o) SELECT t0.s, t1.o FROM "dbrdf_meanTemperature_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 = 27077 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27077, t0.o FROM "dbrdf_meanTemperature_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_meanTemperature_delta_old0";
        INSERT INTO "dbrdf_meanTemperature_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_meanTemperature_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_meanTemperature_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 596
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_author_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_author_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27078;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_author_delta_old" ON "dbrdf_author_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_author_delta_old" ON "dbrdf_author_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_author_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 597
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_abstract_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_abstract_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27079;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_abstract_delta_old" ON "dbrdf_abstract_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_abstract_delta_old" ON "dbrdf_abstract_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_abstract_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 598
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_activeYearsStartDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_activeYearsStartDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27080;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_activeYearsStartDate_delta_old" ON "dbrdf_activeYearsStartDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_activeYearsStartDate_delta_old" ON "dbrdf_activeYearsStartDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_activeYearsStartDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 599
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_manager_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_manager_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27081;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_manager_delta_old" ON "dbrdf_manager_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_manager_delta_old" ON "dbrdf_manager_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_manager_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 600
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Arachnid_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Arachnid_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27082;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Arachnid_delta_old" ON "dbrdf_Arachnid_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Arachnid_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/Arachnid$delta_new>(?Y) :- <http://dbpedia.org/ontology/Arachnid$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Arachnid_delta_new"(s) SELECT t1.o FROM "dbrdf_Arachnid_delta_old" t0, "__triples" t1 WHERE 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 = 27082);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 601
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Village_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Village_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27083;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Village_delta_old" ON "dbrdf_Village_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Village_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/Village$delta_new>(?Y) :- <http://dbpedia.org/ontology/Village$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Village_delta_new"(s) SELECT t1.o FROM "dbrdf_Village_delta_old" t0, "__triples" t1 WHERE 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 = 27083);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 602
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_episodeNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_episodeNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27084;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_episodeNumber_delta_old" ON "dbrdf_episodeNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_episodeNumber_delta_old" ON "dbrdf_episodeNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_episodeNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 603
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_completionDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_completionDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27085;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_completionDate_delta_old" ON "dbrdf_completionDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_completionDate_delta_old" ON "dbrdf_completionDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_completionDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 604
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_bestFinish_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_bestFinish_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27086;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_bestFinish_delta_old" ON "dbrdf_bestFinish_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_bestFinish_delta_old" ON "dbrdf_bestFinish_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_bestFinish_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 605
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtAus_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtAus_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27087;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtAus_delta_old" ON "dbrdf_winsAtAus_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtAus_delta_old" ON "dbrdf_winsAtAus_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtAus_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 606
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_otherChannel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_otherChannel_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27088;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_otherChannel_delta_old" ON "dbrdf_otherChannel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_otherChannel_delta_old" ON "dbrdf_otherChannel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_otherChannel_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 607
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cmykCoordinateYellow_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cmykCoordinateYellow_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27089;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cmykCoordinateYellow_delta_old" ON "dbrdf_cmykCoordinateYellow_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_cmykCoordinateYellow_delta_old" ON "dbrdf_cmykCoordinateYellow_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cmykCoordinateYellow_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 608
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfLanes_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfLanes_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27090;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfLanes_delta_old" ON "dbrdf_numberOfLanes_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfLanes_delta_old" ON "dbrdf_numberOfLanes_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfLanes_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 609
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_bodyDiscovered_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_bodyDiscovered_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27091;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_bodyDiscovered_delta_old" ON "dbrdf_bodyDiscovered_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_bodyDiscovered_delta_old" ON "dbrdf_bodyDiscovered_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_bodyDiscovered_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 610
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_declination_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_declination_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27092;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_declination_delta_old" ON "dbrdf_declination_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_declination_delta_old" ON "dbrdf_declination_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_declination_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 611
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_iafdId_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_iafdId_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27093;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_iafdId_delta_old" ON "dbrdf_iafdId_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_iafdId_delta_old" ON "dbrdf_iafdId_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_iafdId_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 612
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_statisticYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_statisticYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27094;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_statisticYear_delta_old" ON "dbrdf_statisticYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_statisticYear_delta_old" ON "dbrdf_statisticYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_statisticYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 613
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_district_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_district_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27095;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_district_delta_old" ON "dbrdf_district_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_district_delta_old" ON "dbrdf_district_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_district_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 614
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Moss_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Moss_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27096;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Moss_delta_old" ON "dbrdf_Moss_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Moss_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/Moss$delta_new>(?Y) :- <http://dbpedia.org/ontology/Moss$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Moss_delta_new"(s) SELECT t1.o FROM "dbrdf_Moss_delta_old" t0, "__triples" t1 WHERE 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 = 27096);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 615
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_countySeat_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_countySeat_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27097;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_countySeat_delta_old" ON "dbrdf_countySeat_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_countySeat_delta_old" ON "dbrdf_countySeat_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_countySeat_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 616
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_meltingPoint_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_meltingPoint_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27098;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_meltingPoint_delta_old" ON "dbrdf_meltingPoint_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_meltingPoint_delta_old" ON "dbrdf_meltingPoint_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_meltingPoint_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 617
    ---- DEPENDS ON: 616, 485, 75, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

    -- [Rule] <http://dbpedia.org/ontology/Drug>(?X) :- <http://dbpedia.org/ontology/iupacName>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27099 FROM "__triples" t0 WHERE t0.p = 26557 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27099);
    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_Drug_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Drug_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27099;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Drug_delta_old" ON "dbrdf_Drug_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Drug_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/Drug$delta_new>(?Y) :- <http://dbpedia.org/ontology/Drug$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Drug_delta_new"(s) SELECT t1.o FROM "dbrdf_Drug_delta_old" t0, "__triples" t1 WHERE 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 = 27099);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 618
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_width_delta_old2"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_width_delta_old2"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27100;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_width_delta_old2" ON "dbrdf_width_delta_old2"(s, o); CREATE INDEX "IDX_1_dbrdf_width_delta_old2" ON "dbrdf_width_delta_old2"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_width_delta_new2"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 619
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_extinctionYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_extinctionYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27101;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_extinctionYear_delta_old" ON "dbrdf_extinctionYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_extinctionYear_delta_old" ON "dbrdf_extinctionYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_extinctionYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 620
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Reptile$delta_new>(?Y) :- <http://dbpedia.org/ontology/Reptile$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Reptile_delta_new"(s) SELECT t1.o FROM "dbrdf_Reptile_delta_old" t0, "__triples" t1 WHERE 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 = 27102);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 621
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 622
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_campusSize_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_campusSize_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27104;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_campusSize_delta_old0" ON "dbrdf_campusSize_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_campusSize_delta_old0" ON "dbrdf_campusSize_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_campusSize_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 623
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 624
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/MusicFestival$delta_new>(?Y) :- <http://dbpedia.org/ontology/MusicFestival$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_MusicFestival_delta_new"(s) SELECT t1.o FROM "dbrdf_MusicFestival_delta_old" t0, "__triples" t1 WHERE 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 = 27106);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 625
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 626
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 627
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 628
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/BiologicalDatabase$delta_new>(?Y) :- <http://dbpedia.org/ontology/BiologicalDatabase$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_BiologicalDatabase_delta_new"(s) SELECT t1.o FROM "dbrdf_BiologicalDatabase_delta_old" t0, "__triples" t1 WHERE 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 = 27110);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 629
    ---- DEPENDS ON: 628, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Database$delta_new>(?Y) :- <http://dbpedia.org/ontology/Database$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Database_delta_new"(s) SELECT t1.o FROM "dbrdf_Database_delta_old" t0, "__triples" t1 WHERE 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 = 27111);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 630
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 631
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 632
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 633
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumTemperature_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_maximumTemperature_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27115;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_maximumTemperature_delta_old" ON "dbrdf_maximumTemperature_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_maximumTemperature_delta_old" ON "dbrdf_maximumTemperature_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumTemperature_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 634
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 635
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_orbitalInclination_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_orbitalInclination_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27117;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_orbitalInclination_delta_old" ON "dbrdf_orbitalInclination_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_orbitalInclination_delta_old" ON "dbrdf_orbitalInclination_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_orbitalInclination_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 636
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_filmAudioType_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_filmAudioType_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27118;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_filmAudioType_delta_old" ON "dbrdf_filmAudioType_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_filmAudioType_delta_old" ON "dbrdf_filmAudioType_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_filmAudioType_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 637
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_commandModule_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_commandModule_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27119;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_commandModule_delta_old" ON "dbrdf_commandModule_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_commandModule_delta_old" ON "dbrdf_commandModule_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_commandModule_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 638
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cornishName_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cornishName_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27120;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cornishName_delta_old" ON "dbrdf_cornishName_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_cornishName_delta_old" ON "dbrdf_cornishName_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cornishName_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 639
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Senator_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Senator_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27121;
    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);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Senator_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/Senator$delta_new>(?Y) :- <http://dbpedia.org/ontology/Senator$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Senator_delta_new"(s) SELECT t1.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 = 2 AND ex.o = 27121);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 640
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Criminal_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Criminal_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27122;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Criminal_delta_old" ON "dbrdf_Criminal_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Criminal_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/Criminal$delta_new>(?Y) :- <http://dbpedia.org/ontology/Criminal$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Criminal_delta_new"(s) SELECT t1.o FROM "dbrdf_Criminal_delta_old" t0, "__triples" t1 WHERE 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 = 27122);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 641
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_latestPreviewDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_latestPreviewDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27123;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_latestPreviewDate_delta_old" ON "dbrdf_latestPreviewDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_latestPreviewDate_delta_old" ON "dbrdf_latestPreviewDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_latestPreviewDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 642
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_parentMountainPeak_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_parentMountainPeak_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27124;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_parentMountainPeak_delta_old" ON "dbrdf_parentMountainPeak_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_parentMountainPeak_delta_old" ON "dbrdf_parentMountainPeak_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_parentMountainPeak_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 643
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftPatrol_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftPatrol_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27125;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftPatrol_delta_old" ON "dbrdf_aircraftPatrol_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftPatrol_delta_old" ON "dbrdf_aircraftPatrol_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftPatrol_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 644
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

