        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 = 27958 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27958, 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 1468
    ---- DEPENDS ON: 1393, 1268, 1114, 1101, 957, 770, 499, 377, 348, 198, 159, 77, 6, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Language>(?X) :- <http://dbpedia.org/ontology/languageFamily>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27959 FROM "__triples" t0 WHERE t0.p = 26487 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27959);
    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_Language_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Language_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27959;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Language_delta_old" ON "dbrdf_Language_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Language_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Language_delta_old0"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Language_delta_old0"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27960;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Language_delta_old0" ON "dbrdf_Language_delta_old0"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Language_delta_new0"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Language$delta_new>(?X) :- <http://schema.org/Language$delta_old>(?X) .
        INSERT INTO "dbrdf_Language_delta_new"(s) SELECT t0.s FROM "dbrdf_Language_delta_old0" t0 WHERE NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27959);


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


        -- <http://schema.org/Language$delta_new>(?X) :- <http://dbpedia.org/ontology/Language$delta_old>(?X) .
        INSERT INTO "dbrdf_Language_delta_new0"(s) SELECT t0.s FROM "dbrdf_Language_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27960);


        -- <http://schema.org/Language$delta_new>(?Y) :- <http://schema.org/Language$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Language_delta_new0"(s) SELECT t1.o FROM "dbrdf_Language_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 = 2 AND ex.o = 27960);


        -- Propagate $delta_new

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

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27960 FROM "dbrdf_Language_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_Language_delta_old0";
        INSERT INTO "dbrdf_Language_delta_old0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Language_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_Language_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1469
    ---- 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 = 27961;
    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/distanceTraveled$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/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 = 27961 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/distanceTraveled$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/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 = 27961 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27961, 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 1470
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_neighbourConstellations_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_neighbourConstellations_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27962;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_neighbourConstellations_delta_old" ON "dbrdf_neighbourConstellations_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_neighbourConstellations_delta_old" ON "dbrdf_neighbourConstellations_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_neighbourConstellations_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1471
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_secondCommander_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_secondCommander_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27963;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_secondCommander_delta_old" ON "dbrdf_secondCommander_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_secondCommander_delta_old" ON "dbrdf_secondCommander_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_secondCommander_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1472
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationTotal_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_populationTotal_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27964;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_populationTotal_delta_old" ON "dbrdf_populationTotal_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_populationTotal_delta_old" ON "dbrdf_populationTotal_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationTotal_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1473
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lowestPlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lowestPlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27965;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lowestPlace_delta_old" ON "dbrdf_lowestPlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lowestPlace_delta_old" ON "dbrdf_lowestPlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lowestPlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1474
    ---- 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 = 27966;
    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 = 27966 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 = 27966 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27966, 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 1475
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_frazioni_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_frazioni_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27967;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_frazioni_delta_old" ON "dbrdf_frazioni_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_frazioni_delta_old" ON "dbrdf_frazioni_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_frazioni_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1476
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_unicode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_unicode_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27968;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_unicode_delta_old" ON "dbrdf_unicode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_unicode_delta_old" ON "dbrdf_unicode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_unicode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1477
    ---- DEPENDS ON: 1476, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Letter>(?X) :- <http://dbpedia.org/ontology/unicode>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27969 FROM "__triples" t0 WHERE t0.p = 27968 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27969);
    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_Letter_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Letter_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27969;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Letter_delta_old" ON "dbrdf_Letter_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Letter_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/Letter$delta_new>(?Y) :- <http://dbpedia.org/ontology/Letter$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Letter_delta_new"(s) SELECT t1.o FROM "dbrdf_Letter_delta_old" t0, "__triples" t1 WHERE 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 = 27969);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1478
    ---- 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 = 27970;
    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 = 27970 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 = 27970 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27970, 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 1479
    ---- 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 = 27971;
    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 = 27971 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 = 27971 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27971, 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 1480
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_totalPopulation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_totalPopulation_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27972;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_totalPopulation_delta_old" ON "dbrdf_totalPopulation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_totalPopulation_delta_old" ON "dbrdf_totalPopulation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_totalPopulation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1481
    ---- DEPENDS ON: 1480, 1276, 625, 259, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/EthnicGroup>(?X1) :- <http://dbpedia.org/ontology/ethnicity>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.o, 2, 27973 FROM "__triples" t0 WHERE t0.p = 26741 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.o AND ex.p = 2 AND ex.o = 27973);
    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_EthnicGroup_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_EthnicGroup_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27973;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_EthnicGroup_delta_old" ON "dbrdf_EthnicGroup_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_EthnicGroup_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/EthnicGroup$delta_new>(?Y) :- <http://dbpedia.org/ontology/EthnicGroup$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_EthnicGroup_delta_new"(s) SELECT t1.o FROM "dbrdf_EthnicGroup_delta_old" t0, "__triples" t1 WHERE 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 = 27973);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1482
    ---- 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 = 27974;
    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 = 27974 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 = 27974 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27974, 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 1483
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_tournamentRecord_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_tournamentRecord_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27975;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_tournamentRecord_delta_old" ON "dbrdf_tournamentRecord_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_tournamentRecord_delta_old" ON "dbrdf_tournamentRecord_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_tournamentRecord_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1484
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_crews_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_crews_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27976;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_crews_delta_old" ON "dbrdf_crews_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_crews_delta_old" ON "dbrdf_crews_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_crews_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1485
    ---- 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 = 27977;
    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 = 27977 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 = 27977 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27977, 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 1486
    ---- 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 = 27978;
    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 = 27978 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 = 27978 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27978, 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 1487
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_premierePlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_premierePlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27979;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_premierePlace_delta_old" ON "dbrdf_premierePlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_premierePlace_delta_old" ON "dbrdf_premierePlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_premierePlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1488
    ---- DEPENDS ON: 1487, 1282, 1178, 1042, 994, 478, 419, 403, 180, 117, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Play>(?X) :- <http://dbpedia.org/ontology/settingOfPlay>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27980 FROM "__triples" t0 WHERE t0.p = 26599 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27980);
    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_Play_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Play_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27980;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Play_delta_old" ON "dbrdf_Play_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Play_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/Play$delta_new>(?Y) :- <http://dbpedia.org/ontology/Play$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Play_delta_new"(s) SELECT t1.o FROM "dbrdf_Play_delta_old" t0, "__triples" t1 WHERE 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 = 27980);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1489
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_principalEngineer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_principalEngineer_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27981;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_principalEngineer_delta_old" ON "dbrdf_principalEngineer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_principalEngineer_delta_old" ON "dbrdf_principalEngineer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_principalEngineer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1490
    ---- 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 = 27982;
    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 = 27982 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 = 27982 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27982, 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 1491
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_height_delta_old3"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_height_delta_old3"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27983;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_height_delta_old3" ON "dbrdf_height_delta_old3"(s, o); CREATE INDEX "IDX_1_dbrdf_height_delta_old3" ON "dbrdf_height_delta_old3"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_height_delta_new3"(s integer, o 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_new3"(s, o) SELECT t1.o, t0.o FROM "dbrdf_height_delta_old3" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27983 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_new3"(s, o) SELECT t0.s, t1.o FROM "dbrdf_height_delta_old3" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27983 AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1492
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_discovered_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_discovered_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27984;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_discovered_delta_old" ON "dbrdf_discovered_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_discovered_delta_old" ON "dbrdf_discovered_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_discovered_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1493
    ---- DEPENDS ON: 1316, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_MusicGenreR_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_MusicGenreR_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27985;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_MusicGenreR_delta_old" ON "dbrdf_MusicGenreR_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_MusicGenreR_delta_old" ON "dbrdf_MusicGenreR_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_MusicGenreR_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1494
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_genre_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_genre_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27986;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_genre_delta_old" ON "dbrdf_genre_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_genre_delta_old" ON "dbrdf_genre_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_genre_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1495
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1496
    ---- 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 = 27988;
    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 = 27988 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 = 27988 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27988, 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 1497
    ---- 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 = 27989;
    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 = 27989 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 = 27989 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27989, 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 1498
    ---- 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 = 27990;
    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 = 27990 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 = 27990 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27990, 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 1499
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_bowlRecord_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_bowlRecord_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27991;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_bowlRecord_delta_old" ON "dbrdf_bowlRecord_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_bowlRecord_delta_old" ON "dbrdf_bowlRecord_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_bowlRecord_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1500
    ---- 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 = 27992;
    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 = 27992 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 = 27992 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27992, 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 1501
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceConfluenceState_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sourceConfluenceState_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27993;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sourceConfluenceState_delta_old" ON "dbrdf_sourceConfluenceState_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sourceConfluenceState_delta_old" ON "dbrdf_sourceConfluenceState_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceConfluenceState_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1502
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_beatifiedDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_beatifiedDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27994;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_beatifiedDate_delta_old" ON "dbrdf_beatifiedDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_beatifiedDate_delta_old" ON "dbrdf_beatifiedDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_beatifiedDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1503
    ---- 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 = 27995;
    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 = 27995 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 = 27995 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27995, 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 1504
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceElevation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sourceElevation_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27996;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sourceElevation_delta_old" ON "dbrdf_sourceElevation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sourceElevation_delta_old" ON "dbrdf_sourceElevation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceElevation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1505
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_routeEndLocation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_routeEndLocation_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27997;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_routeEndLocation_delta_old" ON "dbrdf_routeEndLocation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_routeEndLocation_delta_old" ON "dbrdf_routeEndLocation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_routeEndLocation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1506
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_academicAdvisor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_academicAdvisor_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27998;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_academicAdvisor_delta_old" ON "dbrdf_academicAdvisor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_academicAdvisor_delta_old" ON "dbrdf_academicAdvisor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_academicAdvisor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1507
    ---- DEPENDS ON: 1506, 768, 685, 585, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Scientist>(?X) :- <http://dbpedia.org/ontology/doctoralAdvisor>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27999 FROM "__triples" t0 WHERE t0.p = 27069 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27999);
    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_Scientist_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Scientist_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27999;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Scientist_delta_old" ON "dbrdf_Scientist_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Scientist_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/Scientist$delta_new>(?Y) :- <http://dbpedia.org/ontology/Scientist$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Scientist_delta_new"(s) SELECT t1.o FROM "dbrdf_Scientist_delta_old" t0, "__triples" t1 WHERE 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 = 27999);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1508
    ---- 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 = 28000;
    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 = 28000 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 = 28000 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28000, 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 1509
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_endingTheme_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_endingTheme_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28001;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_endingTheme_delta_old" ON "dbrdf_endingTheme_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_endingTheme_delta_old" ON "dbrdf_endingTheme_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_endingTheme_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1510
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_influencedBy_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_influencedBy_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28002;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_influencedBy_delta_old" ON "dbrdf_influencedBy_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_influencedBy_delta_old" ON "dbrdf_influencedBy_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_influencedBy_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1511
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_bgafdId_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_bgafdId_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28003;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_bgafdId_delta_old" ON "dbrdf_bgafdId_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_bgafdId_delta_old" ON "dbrdf_bgafdId_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_bgafdId_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1512
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dryCargo_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dryCargo_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28004;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dryCargo_delta_old0" ON "dbrdf_dryCargo_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_dryCargo_delta_old0" ON "dbrdf_dryCargo_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dryCargo_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Spacecraft/dryCargo$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Spacecraft/dryCargo$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_dryCargo_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_dryCargo_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 = 28004 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_new0"(s, o) SELECT t0.s, t1.o FROM "dbrdf_dryCargo_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 = 28004 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28004, t0.o FROM "dbrdf_dryCargo_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_dryCargo_delta_old0";
        INSERT INTO "dbrdf_dryCargo_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_dryCargo_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_dryCargo_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1513
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_speedLimit_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_speedLimit_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28005;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_speedLimit_delta_old" ON "dbrdf_speedLimit_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_speedLimit_delta_old" ON "dbrdf_speedLimit_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_speedLimit_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1514
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationMetro_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_populationMetro_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28006;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_populationMetro_delta_old" ON "dbrdf_populationMetro_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_populationMetro_delta_old" ON "dbrdf_populationMetro_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationMetro_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1515
    ---- 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 = 28007;
    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 = 28007);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28007 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 1516
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_architectualBureau_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_architectualBureau_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28008;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_architectualBureau_delta_old" ON "dbrdf_architectualBureau_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_architectualBureau_delta_old" ON "dbrdf_architectualBureau_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_architectualBureau_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1517
    ---- 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 = 28009;
    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 = 28009 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 = 28009 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28009, 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 1518
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_virtualChannel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_virtualChannel_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28010;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_virtualChannel_delta_old" ON "dbrdf_virtualChannel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_virtualChannel_delta_old" ON "dbrdf_virtualChannel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_virtualChannel_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1519
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_viceLeaderParty_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_viceLeaderParty_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28011;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_viceLeaderParty_delta_old" ON "dbrdf_viceLeaderParty_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_viceLeaderParty_delta_old" ON "dbrdf_viceLeaderParty_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_viceLeaderParty_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1520
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_wavelength_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_wavelength_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28012;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_wavelength_delta_old" ON "dbrdf_wavelength_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_wavelength_delta_old" ON "dbrdf_wavelength_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_wavelength_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1521
    ---- 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 = 28013;
    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 = 28013 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 = 28013 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28013, 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 1522
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_secondDriverCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_secondDriverCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28014;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_secondDriverCountry_delta_old" ON "dbrdf_secondDriverCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_secondDriverCountry_delta_old" ON "dbrdf_secondDriverCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_secondDriverCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1523
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_contractAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_contractAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28015;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_contractAward_delta_old" ON "dbrdf_contractAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_contractAward_delta_old" ON "dbrdf_contractAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_contractAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1524
    ---- 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 = 28016;
    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 = 28016 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 = 28016 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28016, 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 1525
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_port1DockedTime_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_port1DockedTime_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28017;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_port1DockedTime_delta_old0" ON "dbrdf_port1DockedTime_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_port1DockedTime_delta_old0" ON "dbrdf_port1DockedTime_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_port1DockedTime_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/port1DockedTime$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/port1DockedTime$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_port1DockedTime_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_port1DockedTime_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 = 28017 AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28017, t0.o FROM "dbrdf_port1DockedTime_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_port1DockedTime_delta_old0";
        INSERT INTO "dbrdf_port1DockedTime_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_port1DockedTime_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_port1DockedTime_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1526
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerBandMember_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_formerBandMember_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28018;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_formerBandMember_delta_old" ON "dbrdf_formerBandMember_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_formerBandMember_delta_old" ON "dbrdf_formerBandMember_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerBandMember_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1527
    ---- 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 = 28019;
    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 = 28019 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 = 28019 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28019, 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 1528
    ---- 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 = 28020;
    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 = 28020 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 = 28020 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28020, 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 1529
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_hsvCoordinateValue_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_hsvCoordinateValue_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28021;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_hsvCoordinateValue_delta_old" ON "dbrdf_hsvCoordinateValue_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_hsvCoordinateValue_delta_old" ON "dbrdf_hsvCoordinateValue_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_hsvCoordinateValue_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1530
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfEpisodes_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfEpisodes_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28022;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfEpisodes_delta_old" ON "dbrdf_numberOfEpisodes_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfEpisodes_delta_old" ON "dbrdf_numberOfEpisodes_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfEpisodes_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1531
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_twinCity_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_twinCity_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28023;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_twinCity_delta_old" ON "dbrdf_twinCity_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_twinCity_delta_old" ON "dbrdf_twinCity_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_twinCity_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1532
    ---- 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 = 28024;
    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 = 28024 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 = 28024 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28024, 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 1533
    ---- 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 = 28025;
    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 = 28025 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 = 28025 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28025, 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 1534
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_startYearOfSales_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_startYearOfSales_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28026;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_startYearOfSales_delta_old" ON "dbrdf_startYearOfSales_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_startYearOfSales_delta_old" ON "dbrdf_startYearOfSales_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_startYearOfSales_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1535
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_floorCount_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_floorCount_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28027;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_floorCount_delta_old" ON "dbrdf_floorCount_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_floorCount_delta_old" ON "dbrdf_floorCount_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_floorCount_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1536
    ---- 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 = 28028;
    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 = 28028 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 = 28028 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28028, 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 1537
    ---- 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 = 28029;
    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 = 28029 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 = 28029 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28029, 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 1538
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_thirdTeam_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_thirdTeam_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28030;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_thirdTeam_delta_old" ON "dbrdf_thirdTeam_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_thirdTeam_delta_old" ON "dbrdf_thirdTeam_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_thirdTeam_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1539
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_imdbId_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_imdbId_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28031;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_imdbId_delta_old" ON "dbrdf_imdbId_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_imdbId_delta_old" ON "dbrdf_imdbId_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_imdbId_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1540
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_goldenRaspberryAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_goldenRaspberryAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28032;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_goldenRaspberryAward_delta_old" ON "dbrdf_goldenRaspberryAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_goldenRaspberryAward_delta_old" ON "dbrdf_goldenRaspberryAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_goldenRaspberryAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1541
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_serviceNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_serviceNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28033;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_serviceNumber_delta_old" ON "dbrdf_serviceNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_serviceNumber_delta_old" ON "dbrdf_serviceNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_serviceNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1542
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaTotal_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_areaTotal_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28034;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_areaTotal_delta_old0" ON "dbrdf_areaTotal_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_areaTotal_delta_old0" ON "dbrdf_areaTotal_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaTotal_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/PopulatedPlace/areaTotal$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/PopulatedPlace/areaTotal$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_areaTotal_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_areaTotal_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 = 28034 AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28034, t0.o FROM "dbrdf_areaTotal_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_areaTotal_delta_old0";
        INSERT INTO "dbrdf_areaTotal_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_areaTotal_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_areaTotal_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1543
    ---- 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 = 28035;
    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 = 28035 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 = 28035 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28035, 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 1544
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsSubsection_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_alpsSubsection_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28036;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_alpsSubsection_delta_old" ON "dbrdf_alpsSubsection_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_alpsSubsection_delta_old" ON "dbrdf_alpsSubsection_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsSubsection_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1545
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_vehicleCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_vehicleCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28037;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_vehicleCode_delta_old" ON "dbrdf_vehicleCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_vehicleCode_delta_old" ON "dbrdf_vehicleCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_vehicleCode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1546
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfVineyards_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfVineyards_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28038;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfVineyards_delta_old" ON "dbrdf_numberOfVineyards_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfVineyards_delta_old" ON "dbrdf_numberOfVineyards_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfVineyards_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1547
    ---- 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 = 28039;
    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 = 28039 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 = 28039 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28039, 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 1548
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cost_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cost_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28040;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cost_delta_old" ON "dbrdf_cost_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_cost_delta_old" ON "dbrdf_cost_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cost_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1549
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_followingEvent_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_followingEvent_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28041;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_followingEvent_delta_old" ON "dbrdf_followingEvent_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_followingEvent_delta_old" ON "dbrdf_followingEvent_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_followingEvent_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1550
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_currency_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_currency_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28042;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_currency_delta_old" ON "dbrdf_currency_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_currency_delta_old" ON "dbrdf_currency_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_currency_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1551
    ---- DEPENDS ON: 1550, 579, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- [Rule] <http://dbpedia.org/ontology/Currency>(?X) :- <http://dbpedia.org/ontology/usingCountry>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28043 FROM "__triples" t0 WHERE t0.p = 27063 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28043);
    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_Currency_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Currency_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 28043;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Currency_delta_old" ON "dbrdf_Currency_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Currency_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/Currency$delta_new>(?Y) :- <http://dbpedia.org/ontology/Currency$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Currency_delta_new"(s) SELECT t1.o FROM "dbrdf_Currency_delta_old" t0, "__triples" t1 WHERE 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 = 28043);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1552
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfMunicipalities_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfMunicipalities_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28044;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfMunicipalities_delta_old" ON "dbrdf_numberOfMunicipalities_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfMunicipalities_delta_old" ON "dbrdf_numberOfMunicipalities_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfMunicipalities_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1553
    ---- 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 = 28045;
    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 = 28045 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 = 28045 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28045, 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 1554
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_board_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_board_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28046;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_board_delta_old" ON "dbrdf_board_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_board_delta_old" ON "dbrdf_board_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_board_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1555
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_wineProduced_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_wineProduced_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28047;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_wineProduced_delta_old" ON "dbrdf_wineProduced_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_wineProduced_delta_old" ON "dbrdf_wineProduced_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_wineProduced_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1556
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nearestCity_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nearestCity_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28048;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nearestCity_delta_old" ON "dbrdf_nearestCity_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nearestCity_delta_old" ON "dbrdf_nearestCity_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nearestCity_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1557
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_vicePrincipal_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_vicePrincipal_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28049;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_vicePrincipal_delta_old" ON "dbrdf_vicePrincipal_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_vicePrincipal_delta_old" ON "dbrdf_vicePrincipal_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_vicePrincipal_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1558
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumBoatLength_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_maximumBoatLength_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28050;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_maximumBoatLength_delta_old0" ON "dbrdf_maximumBoatLength_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_maximumBoatLength_delta_old0" ON "dbrdf_maximumBoatLength_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumBoatLength_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/Canal/maximumBoatLength$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Canal/maximumBoatLength$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_maximumBoatLength_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_maximumBoatLength_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 = 28050 AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28050, t0.o FROM "dbrdf_maximumBoatLength_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_maximumBoatLength_delta_old0";
        INSERT INTO "dbrdf_maximumBoatLength_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_maximumBoatLength_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_maximumBoatLength_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1559
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ageRange_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ageRange_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28051;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ageRange_delta_old" ON "dbrdf_ageRange_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ageRange_delta_old" ON "dbrdf_ageRange_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ageRange_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1560
    ---- 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 = 28052;
    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 = 28052 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 = 28052 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28052, 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 1561
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_associationOfLocalGovernment_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_associationOfLocalGovernment_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28053;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_associationOfLocalGovernment_delta_old" ON "dbrdf_associationOfLocalGovernment_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_associationOfLocalGovernment_delta_old" ON "dbrdf_associationOfLocalGovernment_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_associationOfLocalGovernment_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1562
    ---- 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 = 28054;
    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 = 28054 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 = 28054 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28054, 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 1563
    ---- 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 = 28055;
    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 = 28055 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 = 28055 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28055, 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 1564
    ---- 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 = 28056;
    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 = 28056 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 = 28056 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28056, 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 1565
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sex_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sex_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28057;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sex_delta_old" ON "dbrdf_sex_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sex_delta_old" ON "dbrdf_sex_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sex_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1566
    ---- 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 = 28058;
    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 = 28058);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28058 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 1567
    ---- DEPENDS ON: 1566, 1391, 1110, 1077, 934, 580, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/GridironFootballPlayer>(?X) :- <http://dbpedia.org/ontology/draftPick>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28059 FROM "__triples" t0 WHERE t0.p = 27881 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28059);
    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_GridironFootballPlayer_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_GridironFootballPlayer_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 28059;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_GridironFootballPlayer_delta_old" ON "dbrdf_GridironFootballPlayer_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_GridironFootballPlayer_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/GridironFootballPlayer$delta_new>(?Y) :- <http://dbpedia.org/ontology/GridironFootballPlayer$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_GridironFootballPlayer_delta_new"(s) SELECT t1.o FROM "dbrdf_GridironFootballPlayer_delta_old" t0, "__triples" t1 WHERE 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 = 28059);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1568
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_parentCompany_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_parentCompany_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28060;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_parentCompany_delta_old" ON "dbrdf_parentCompany_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_parentCompany_delta_old" ON "dbrdf_parentCompany_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_parentCompany_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1569
    ---- 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 = 28061;
    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 = 28061);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28061 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 1570
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_capacity_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_capacity_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28062;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_capacity_delta_old" ON "dbrdf_capacity_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_capacity_delta_old" ON "dbrdf_capacity_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_capacity_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1571
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_finalPublicationDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_finalPublicationDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28063;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_finalPublicationDate_delta_old" ON "dbrdf_finalPublicationDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_finalPublicationDate_delta_old" ON "dbrdf_finalPublicationDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_finalPublicationDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1572
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nssdcId_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nssdcId_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28064;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nssdcId_delta_old" ON "dbrdf_nssdcId_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nssdcId_delta_old" ON "dbrdf_nssdcId_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nssdcId_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1573
    ---- DEPENDS ON: 1572, 356, 213, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

    -- [Rule] <http://dbpedia.org/ontology/SpaceStation>(?X1) :- <http://dbpedia.org/ontology/targetSpaceStation>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.o, 2, 28065 FROM "__triples" t0 WHERE t0.p = 26695 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.o AND ex.p = 2 AND ex.o = 28065);
    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_SpaceStation_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SpaceStation_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 28065;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SpaceStation_delta_old" ON "dbrdf_SpaceStation_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SpaceStation_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/SpaceStation$delta_new>(?Y) :- <http://dbpedia.org/ontology/SpaceStation$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_SpaceStation_delta_new"(s) SELECT t1.o FROM "dbrdf_SpaceStation_delta_old" t0, "__triples" t1 WHERE 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 = 28065);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1574
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mouthCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mouthCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28066;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mouthCountry_delta_old" ON "dbrdf_mouthCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mouthCountry_delta_old" ON "dbrdf_mouthCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mouthCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1575
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_currentlyUsedFor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_currentlyUsedFor_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28067;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_currentlyUsedFor_delta_old" ON "dbrdf_currentlyUsedFor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_currentlyUsedFor_delta_old" ON "dbrdf_currentlyUsedFor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_currentlyUsedFor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1576
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1577
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstPublicationYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstPublicationYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28069;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstPublicationYear_delta_old" ON "dbrdf_firstPublicationYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstPublicationYear_delta_old" ON "dbrdf_firstPublicationYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstPublicationYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1578
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1579
    ---- 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 = 28071;
    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 = 28071 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 = 28071 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28071, 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 1580
    ---- 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 = 28072;
    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 = 28072 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 = 28072 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28072, 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 1581
    ---- 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 = 28073;
    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 = 28073 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 = 28073 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28073, 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 1582
    ---- 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 = 28074;
    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 = 28074 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 = 28074 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28074, 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 1583
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_governmentElevation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_governmentElevation_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28075;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_governmentElevation_delta_old" ON "dbrdf_governmentElevation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_governmentElevation_delta_old" ON "dbrdf_governmentElevation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_governmentElevation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1584
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_distanceTraveled_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_distanceTraveled_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28076;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_distanceTraveled_delta_old0" ON "dbrdf_distanceTraveled_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_distanceTraveled_delta_old0" ON "dbrdf_distanceTraveled_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_distanceTraveled_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/SpaceMission/distanceTraveled$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/SpaceMission/distanceTraveled$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_distanceTraveled_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_distanceTraveled_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 = 28076 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_new0"(s, o) SELECT t0.s, t1.o FROM "dbrdf_distanceTraveled_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 = 28076 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28076, t0.o FROM "dbrdf_distanceTraveled_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_distanceTraveled_delta_old0";
        INSERT INTO "dbrdf_distanceTraveled_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_distanceTraveled_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_distanceTraveled_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1585
    ---- 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 = 28077;
    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 = 28077 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 = 28077 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28077, 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 1586
    ---- 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 = 28078;
    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 = 28078 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 = 28078 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28078, 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 1587
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_officialOpenedBy_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_officialOpenedBy_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28079;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_officialOpenedBy_delta_old" ON "dbrdf_officialOpenedBy_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_officialOpenedBy_delta_old" ON "dbrdf_officialOpenedBy_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_officialOpenedBy_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1588
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfOfficials_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfOfficials_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28080;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfOfficials_delta_old" ON "dbrdf_numberOfOfficials_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfOfficials_delta_old" ON "dbrdf_numberOfOfficials_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfOfficials_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1589
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_fundedBy_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_fundedBy_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28081;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_fundedBy_delta_old" ON "dbrdf_fundedBy_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_fundedBy_delta_old" ON "dbrdf_fundedBy_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_fundedBy_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1590
    ---- DEPENDS ON: 1589, 1585, 1249, 1120, 562, 364, 252, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/ResearchProject>(?X) :- <http://dbpedia.org/ontology/projectReferenceID>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28082 FROM "__triples" t0 WHERE t0.p = 27045 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28082);
    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_ResearchProject_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ResearchProject_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 28082;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ResearchProject_delta_old" ON "dbrdf_ResearchProject_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ResearchProject_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/ResearchProject$delta_new>(?Y) :- <http://dbpedia.org/ontology/ResearchProject$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_ResearchProject_delta_new"(s) SELECT t1.o FROM "dbrdf_ResearchProject_delta_old" t0, "__triples" t1 WHERE 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 = 28082);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1591
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_provost_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_provost_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28083;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_provost_delta_old" ON "dbrdf_provost_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_provost_delta_old" ON "dbrdf_provost_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_provost_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1592
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_port1UndockingDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_port1UndockingDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28084;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_port1UndockingDate_delta_old" ON "dbrdf_port1UndockingDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_port1UndockingDate_delta_old" ON "dbrdf_port1UndockingDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_port1UndockingDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1593
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_committeeInLegislature_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_committeeInLegislature_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28085;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_committeeInLegislature_delta_old" ON "dbrdf_committeeInLegislature_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_committeeInLegislature_delta_old" ON "dbrdf_committeeInLegislature_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_committeeInLegislature_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1594
    ---- DEPENDS ON: 1593, 1346, 1026, 804, 679, 617, 604, 489, 281, 138, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Legislature>(?X) :- <http://dbpedia.org/ontology/house>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28086 FROM "__triples" t0 WHERE t0.p = 26620 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28086);
    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_Legislature_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Legislature_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 28086;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Legislature_delta_old" ON "dbrdf_Legislature_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Legislature_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/Legislature$delta_new>(?Y) :- <http://dbpedia.org/ontology/Legislature$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Legislature_delta_new"(s) SELECT t1.o FROM "dbrdf_Legislature_delta_old" t0, "__triples" t1 WHERE 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 = 28086);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1595
    ---- 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 = 28087;
    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 = 28087 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 = 28087 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28087, 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 1596
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_serviceEndYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_serviceEndYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28088;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_serviceEndYear_delta_old" ON "dbrdf_serviceEndYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_serviceEndYear_delta_old" ON "dbrdf_serviceEndYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_serviceEndYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1597
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_appearancesInNationalTeam_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_appearancesInNationalTeam_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28089;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_appearancesInNationalTeam_delta_old" ON "dbrdf_appearancesInNationalTeam_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_appearancesInNationalTeam_delta_old" ON "dbrdf_appearancesInNationalTeam_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_appearancesInNationalTeam_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1598
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_regionType_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_regionType_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28090;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_regionType_delta_old" ON "dbrdf_regionType_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_regionType_delta_old" ON "dbrdf_regionType_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_regionType_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1599
    ---- DEPENDS ON: 1439, 1055, 319, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

    -- [Rule] <http://dbpedia.org/ontology/Race>(?X) :- <http://dbpedia.org/ontology/mostWins>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28091 FROM "__triples" t0 WHERE t0.p = 26801 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28091);
    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_Race_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Race_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 28091;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Race_delta_old" ON "dbrdf_Race_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Race_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/Race$delta_new>(?Y) :- <http://dbpedia.org/ontology/Race$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Race_delta_new"(s) SELECT t1.o FROM "dbrdf_Race_delta_old" t0, "__triples" t1 WHERE 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 = 28091);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1600
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_apoapsis_delta_old2"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_apoapsis_delta_old2"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28092;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_apoapsis_delta_old2" ON "dbrdf_apoapsis_delta_old2"(s, o); CREATE INDEX "IDX_1_dbrdf_apoapsis_delta_old2" ON "dbrdf_apoapsis_delta_old2"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_apoapsis_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/Planet/apoapsis$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Planet/apoapsis$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_apoapsis_delta_new2"(s, o) SELECT t1.o, t0.o FROM "dbrdf_apoapsis_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 = 28092 AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28092, t0.o FROM "dbrdf_apoapsis_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_apoapsis_delta_old2";
        INSERT INTO "dbrdf_apoapsis_delta_old2"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_apoapsis_delta_new2" t0;
        TRUNCATE TABLE "dbrdf_apoapsis_delta_new2";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1601
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_topSpeed_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_topSpeed_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28093;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_topSpeed_delta_old0" ON "dbrdf_topSpeed_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_topSpeed_delta_old0" ON "dbrdf_topSpeed_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_topSpeed_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28093, t0.o FROM "dbrdf_topSpeed_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_topSpeed_delta_old0";
        INSERT INTO "dbrdf_topSpeed_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_topSpeed_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_topSpeed_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1602
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfSports_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfSports_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28094;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfSports_delta_old" ON "dbrdf_numberOfSports_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfSports_delta_old" ON "dbrdf_numberOfSports_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfSports_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1603
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_olympicOathSwornByAthlete_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_olympicOathSwornByAthlete_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28095;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_olympicOathSwornByAthlete_delta_old" ON "dbrdf_olympicOathSwornByAthlete_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_olympicOathSwornByAthlete_delta_old" ON "dbrdf_olympicOathSwornByAthlete_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_olympicOathSwornByAthlete_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1604
    ---- DEPENDS ON: 1603, 1587, 1012, 907, 720, 496, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Olympics>(?X) :- <http://dbpedia.org/ontology/numberOfParticipatingNations>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28096 FROM "__triples" t0 WHERE t0.p = 27204 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28096);
    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_Olympics_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Olympics_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 28096;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Olympics_delta_old" ON "dbrdf_Olympics_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Olympics_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/Olympics$delta_new>(?Y) :- <http://dbpedia.org/ontology/Olympics$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Olympics_delta_new"(s) SELECT t1.o FROM "dbrdf_Olympics_delta_old" t0, "__triples" t1 WHERE 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 = 28096);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1605
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_result_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_result_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28097;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_result_delta_old" ON "dbrdf_result_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_result_delta_old" ON "dbrdf_result_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_result_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1606
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_distanceToEdinburgh_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_distanceToEdinburgh_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28098;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_distanceToEdinburgh_delta_old" ON "dbrdf_distanceToEdinburgh_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_distanceToEdinburgh_delta_old" ON "dbrdf_distanceToEdinburgh_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_distanceToEdinburgh_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1607
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_circulation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_circulation_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28099;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_circulation_delta_old" ON "dbrdf_circulation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_circulation_delta_old" ON "dbrdf_circulation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_circulation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1608
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_highestPosition_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_highestPosition_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28100;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_highestPosition_delta_old" ON "dbrdf_highestPosition_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_highestPosition_delta_old" ON "dbrdf_highestPosition_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_highestPosition_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1609
    ---- DEPENDS ON: 1608, 1376, 1325, 1124, 836, 418, 181, 96, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://www.w3.org/2003/01/geo/wgs84_pos#SpatialThing>(?X1) :- <http://dbpedia.org/ontology/highestPosition>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.o, 2, 28101 FROM "__triples" t0 WHERE t0.p = 28100 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.o AND ex.p = 2 AND ex.o = 28101);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://www.w3.org/2003/01/geo/wgs84_pos#SpatialThing>(?X1) :- <http://dbpedia.org/ontology/sourceConfluencePosition>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.o, 2, 28101 FROM "__triples" t0 WHERE t0.p = 27815 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.o AND ex.p = 2 AND ex.o = 28101);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://www.w3.org/2003/01/geo/wgs84_pos#SpatialThing>(?X1) :- <http://dbpedia.org/ontology/restingPlacePosition>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.o, 2, 28101 FROM "__triples" t0 WHERE t0.p = 27611 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.o AND ex.p = 2 AND ex.o = 28101);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://www.w3.org/2003/01/geo/wgs84_pos#SpatialThing>(?X1) :- <http://dbpedia.org/ontology/capitalPosition>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.o, 2, 28101 FROM "__triples" t0 WHERE t0.p = 27323 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.o AND ex.p = 2 AND ex.o = 28101);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://www.w3.org/2003/01/geo/wgs84_pos#SpatialThing>(?X1) :- <http://dbpedia.org/ontology/governmentPosition>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.o, 2, 28101 FROM "__triples" t0 WHERE t0.p = 27866 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.o AND ex.p = 2 AND ex.o = 28101);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://www.w3.org/2003/01/geo/wgs84_pos#SpatialThing>(?X1) :- <http://dbpedia.org/ontology/mouthPosition>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.o, 2, 28101 FROM "__triples" t0 WHERE t0.p = 26901 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.o AND ex.p = 2 AND ex.o = 28101);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://www.w3.org/2003/01/geo/wgs84_pos#SpatialThing>(?X1) :- <http://dbpedia.org/ontology/lowestPosition>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.o, 2, 28101 FROM "__triples" t0 WHERE t0.p = 26663 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.o AND ex.p = 2 AND ex.o = 28101);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://www.w3.org/2003/01/geo/wgs84_pos#SpatialThing>(?X1) :- <http://dbpedia.org/ontology/sourcePosition>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.o, 2, 28101 FROM "__triples" t0 WHERE t0.p = 26578 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.o AND ex.p = 2 AND ex.o = 28101);
    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_SpatialThing_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SpatialThing_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 28101;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SpatialThing_delta_old" ON "dbrdf_SpatialThing_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SpatialThing_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://www.w3.org/2003/01/geo/wgs84_pos#SpatialThing$delta_new>(?Y) :- <http://www.w3.org/2003/01/geo/wgs84_pos#SpatialThing$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_SpatialThing_delta_new"(s) SELECT t1.o FROM "dbrdf_SpatialThing_delta_old" t0, "__triples" t1 WHERE 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 = 28101);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1610
    ---- 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 = 28102;
    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 = 28102 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 = 28102 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 28102, 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 1611
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_subtitle_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_subtitle_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28103;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_subtitle_delta_old" ON "dbrdf_subtitle_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_subtitle_delta_old" ON "dbrdf_subtitle_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_subtitle_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1612
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_intercommunality_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_intercommunality_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28104;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_intercommunality_delta_old" ON "dbrdf_intercommunality_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_intercommunality_delta_old" ON "dbrdf_intercommunality_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_intercommunality_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1613
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_shipLaunch_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_shipLaunch_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28105;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_shipLaunch_delta_old" ON "dbrdf_shipLaunch_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_shipLaunch_delta_old" ON "dbrdf_shipLaunch_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_shipLaunch_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1614
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_publiclyAccessible_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_publiclyAccessible_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28106;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_publiclyAccessible_delta_old" ON "dbrdf_publiclyAccessible_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_publiclyAccessible_delta_old" ON "dbrdf_publiclyAccessible_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_publiclyAccessible_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1615
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_availableSmartCard_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_availableSmartCard_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28107;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_availableSmartCard_delta_old" ON "dbrdf_availableSmartCard_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_availableSmartCard_delta_old" ON "dbrdf_availableSmartCard_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_availableSmartCard_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1616
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_inflow_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_inflow_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28108;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_inflow_delta_old" ON "dbrdf_inflow_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_inflow_delta_old" ON "dbrdf_inflow_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_inflow_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1617
    ---- 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 = 28109;
    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 = 28109 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 = 28109 AND ex.o = t1.o);


        -- Propagate $delta_new

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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28110 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 1619
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_fourthCommander_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_fourthCommander_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28111;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_fourthCommander_delta_old" ON "dbrdf_fourthCommander_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_fourthCommander_delta_old" ON "dbrdf_fourthCommander_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_fourthCommander_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1620
    ---- 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 = 28112;
    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 = 28112);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28112 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 1621
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfCountries_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfCountries_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 28113;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfCountries_delta_old" ON "dbrdf_numberOfCountries_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfCountries_delta_old" ON "dbrdf_numberOfCountries_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfCountries_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1622
    ---- DEPENDS ON: 1621, 631, 43, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

    -- [Rule] <http://dbpedia.org/ontology/AdministrativeRegion>(?X) :- <http://dbpedia.org/ontology/congressionalDistrict>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 28115 FROM "__triples" t0 WHERE t0.p = 26524 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28115);
    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_AdministrativeArea_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_AdministrativeArea_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 28114;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_AdministrativeArea_delta_old" ON "dbrdf_AdministrativeArea_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_AdministrativeArea_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_AdministrativeRegion_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_AdministrativeRegion_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 28115;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_AdministrativeRegion_delta_old" ON "dbrdf_AdministrativeRegion_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_AdministrativeRegion_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://schema.org/AdministrativeArea$delta_new>(?X) :- <http://dbpedia.org/ontology/AdministrativeRegion$delta_old>(?X) .
        INSERT INTO "dbrdf_AdministrativeArea_delta_new"(s) SELECT t0.s FROM "dbrdf_AdministrativeRegion_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28114);


        -- <http://schema.org/AdministrativeArea$delta_new>(?Y) :- <http://schema.org/AdministrativeArea$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_AdministrativeArea_delta_new"(s) SELECT t1.o FROM "dbrdf_AdministrativeArea_delta_old" t0, "__triples" t1 WHERE 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 = 28114);


        -- <http://dbpedia.org/ontology/AdministrativeRegion$delta_new>(?X) :- <http://schema.org/AdministrativeArea$delta_old>(?X) .
        INSERT INTO "dbrdf_AdministrativeRegion_delta_new"(s) SELECT t0.s FROM "dbrdf_AdministrativeArea_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 28115);


        -- <http://dbpedia.org/ontology/AdministrativeRegion$delta_new>(?Y) :- <http://dbpedia.org/ontology/AdministrativeRegion$delta_old>(?X0), owl:sameAs(?X0,?Y) .
