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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 806
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_company_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_company_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27293;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_company_delta_old" ON "dbrdf_company_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_company_delta_old" ON "dbrdf_company_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_company_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 807
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_superintendent_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_superintendent_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27294;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_superintendent_delta_old" ON "dbrdf_superintendent_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_superintendent_delta_old" ON "dbrdf_superintendent_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_superintendent_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 808
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 809
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_serviceStartDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_serviceStartDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27296;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_serviceStartDate_delta_old" ON "dbrdf_serviceStartDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_serviceStartDate_delta_old" ON "dbrdf_serviceStartDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_serviceStartDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 810
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rightChild_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rightChild_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27297;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rightChild_delta_old" ON "dbrdf_rightChild_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rightChild_delta_old" ON "dbrdf_rightChild_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rightChild_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 811
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 812
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaLand_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_areaLand_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27299;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_areaLand_delta_old" ON "dbrdf_areaLand_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_areaLand_delta_old" ON "dbrdf_areaLand_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaLand_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 813
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 814
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfOrbits_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfOrbits_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27301;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfOrbits_delta_old" ON "dbrdf_numberOfOrbits_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfOrbits_delta_old" ON "dbrdf_numberOfOrbits_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfOrbits_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 815
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_component_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_component_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27302;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_component_delta_old" ON "dbrdf_component_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_component_delta_old" ON "dbrdf_component_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_component_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 816
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 817
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_reopeningYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_reopeningYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27304;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_reopeningYear_delta_old" ON "dbrdf_reopeningYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_reopeningYear_delta_old" ON "dbrdf_reopeningYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_reopeningYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 818
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_internationalAffiliation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_internationalAffiliation_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27305;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_internationalAffiliation_delta_old" ON "dbrdf_internationalAffiliation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_internationalAffiliation_delta_old" ON "dbrdf_internationalAffiliation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_internationalAffiliation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 819
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 820
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_silverMedalist_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_silverMedalist_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27307;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_silverMedalist_delta_old" ON "dbrdf_silverMedalist_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_silverMedalist_delta_old" ON "dbrdf_silverMedalist_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_silverMedalist_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 821
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27308, t0.o FROM "dbrdf_area_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_area_delta_old0";
        INSERT INTO "dbrdf_area_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_area_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_area_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 822
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_jstor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_jstor_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27309;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_jstor_delta_old" ON "dbrdf_jstor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_jstor_delta_old" ON "dbrdf_jstor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_jstor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 823
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 824
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_runwayLength_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_runwayLength_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27311;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_runwayLength_delta_old" ON "dbrdf_runwayLength_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_runwayLength_delta_old" ON "dbrdf_runwayLength_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_runwayLength_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 825
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_minimumTemperature_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_minimumTemperature_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27312;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_minimumTemperature_delta_old0" ON "dbrdf_minimumTemperature_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_minimumTemperature_delta_old0" ON "dbrdf_minimumTemperature_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_minimumTemperature_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 826
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 827
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_relative_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_relative_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27314;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_relative_delta_old" ON "dbrdf_relative_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_relative_delta_old" ON "dbrdf_relative_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_relative_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 828
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 829
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_distributor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_distributor_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27316;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_distributor_delta_old" ON "dbrdf_distributor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_distributor_delta_old" ON "dbrdf_distributor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_distributor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 830
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_bustSize_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_bustSize_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27317;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_bustSize_delta_old" ON "dbrdf_bustSize_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_bustSize_delta_old" ON "dbrdf_bustSize_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_bustSize_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 831
    ---- DEPENDS ON: 577, 369, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- [Rule] <http://dbpedia.org/ontology/LawFirm>(?X) :- <http://dbpedia.org/ontology/numberOfLawyers>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27318 FROM "__triples" t0 WHERE t0.p = 27061 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27318);
    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_LawFirm_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_LawFirm_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27318;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_LawFirm_delta_old" ON "dbrdf_LawFirm_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_LawFirm_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/LawFirm$delta_new>(?Y) :- <http://dbpedia.org/ontology/LawFirm$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_LawFirm_delta_new"(s) SELECT t1.o FROM "dbrdf_LawFirm_delta_old" t0, "__triples" t1 WHERE 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 = 27318);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 832
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_hgncid_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_hgncid_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27319;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_hgncid_delta_old" ON "dbrdf_hgncid_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_hgncid_delta_old" ON "dbrdf_hgncid_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_hgncid_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 833
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_plays_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_plays_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27320;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_plays_delta_old" ON "dbrdf_plays_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_plays_delta_old" ON "dbrdf_plays_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_plays_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 834
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_battleHonours_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_battleHonours_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27321;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_battleHonours_delta_old" ON "dbrdf_battleHonours_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_battleHonours_delta_old" ON "dbrdf_battleHonours_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_battleHonours_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 835
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 836
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 837
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lymph_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lymph_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27324;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lymph_delta_old" ON "dbrdf_lymph_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lymph_delta_old" ON "dbrdf_lymph_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lymph_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 838
    ---- DEPENDS ON: 837, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Lymph>(?X1) :- <http://dbpedia.org/ontology/lymph>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.o, 2, 27325 FROM "__triples" t0 WHERE t0.p = 27324 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.o AND ex.p = 2 AND ex.o = 27325);
    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_Lymph_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Lymph_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27325;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Lymph_delta_old" ON "dbrdf_Lymph_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Lymph_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/Lymph$delta_new>(?Y) :- <http://dbpedia.org/ontology/Lymph$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Lymph_delta_new"(s) SELECT t1.o FROM "dbrdf_Lymph_delta_old" t0, "__triples" t1 WHERE 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 = 27325);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 839
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 840
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfCapitalDeputies_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfCapitalDeputies_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27327;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfCapitalDeputies_delta_old" ON "dbrdf_numberOfCapitalDeputies_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfCapitalDeputies_delta_old" ON "dbrdf_numberOfCapitalDeputies_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfCapitalDeputies_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 841
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 842
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_measurements_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_measurements_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27329;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_measurements_delta_old" ON "dbrdf_measurements_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_measurements_delta_old" ON "dbrdf_measurements_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_measurements_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 843
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 844
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 845
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_countryWithFirstSatellite_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_countryWithFirstSatellite_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27332;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_countryWithFirstSatellite_delta_old" ON "dbrdf_countryWithFirstSatellite_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_countryWithFirstSatellite_delta_old" ON "dbrdf_countryWithFirstSatellite_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_countryWithFirstSatellite_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 846
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_statisticLabel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_statisticLabel_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27333;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_statisticLabel_delta_old" ON "dbrdf_statisticLabel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_statisticLabel_delta_old" ON "dbrdf_statisticLabel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_statisticLabel_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 847
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_school_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_school_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27334;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_school_delta_old" ON "dbrdf_school_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_school_delta_old" ON "dbrdf_school_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_school_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 848
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_incumbent_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_incumbent_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27335;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_incumbent_delta_old" ON "dbrdf_incumbent_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_incumbent_delta_old" ON "dbrdf_incumbent_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_incumbent_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 849
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nerve_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nerve_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27336;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nerve_delta_old" ON "dbrdf_nerve_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nerve_delta_old" ON "dbrdf_nerve_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nerve_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 850
    ---- DEPENDS ON: 849, 459, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- [Rule] <http://dbpedia.org/ontology/Nerve>(?X1) :- <http://dbpedia.org/ontology/nerve>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.o, 2, 27337 FROM "__triples" t0 WHERE t0.p = 27336 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.o AND ex.p = 2 AND ex.o = 27337);
    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_Nerve_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Nerve_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27337;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Nerve_delta_old" ON "dbrdf_Nerve_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Nerve_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/Nerve$delta_new>(?Y) :- <http://dbpedia.org/ontology/Nerve$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Nerve_delta_new"(s) SELECT t1.o FROM "dbrdf_Nerve_delta_old" t0, "__triples" t1 WHERE 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 = 27337);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 851
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 852
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_access_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_access_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27339;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_access_delta_old" ON "dbrdf_access_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_access_delta_old" ON "dbrdf_access_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_access_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 853
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerHighschool_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_formerHighschool_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27340;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_formerHighschool_delta_old" ON "dbrdf_formerHighschool_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_formerHighschool_delta_old" ON "dbrdf_formerHighschool_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_formerHighschool_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 854
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfParkingSpaces_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfParkingSpaces_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27341;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfParkingSpaces_delta_old" ON "dbrdf_numberOfParkingSpaces_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfParkingSpaces_delta_old" ON "dbrdf_numberOfParkingSpaces_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfParkingSpaces_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 855
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_height_delta_old2"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_height_delta_old2"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27342;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_height_delta_old2" ON "dbrdf_height_delta_old2"(s, o); CREATE INDEX "IDX_1_dbrdf_height_delta_old2" ON "dbrdf_height_delta_old2"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_height_delta_new2"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27342, t0.o FROM "dbrdf_height_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_height_delta_old2";
        INSERT INTO "dbrdf_height_delta_old2"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_height_delta_new2" t0;
        TRUNCATE TABLE "dbrdf_height_delta_new2";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 856
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftHelicopterMultirole_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftHelicopterMultirole_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27343;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftHelicopterMultirole_delta_old" ON "dbrdf_aircraftHelicopterMultirole_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftHelicopterMultirole_delta_old" ON "dbrdf_aircraftHelicopterMultirole_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftHelicopterMultirole_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 857
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_notifyDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_notifyDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27344;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_notifyDate_delta_old" ON "dbrdf_notifyDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_notifyDate_delta_old" ON "dbrdf_notifyDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_notifyDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 858
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_membership_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_membership_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27345;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_membership_delta_old" ON "dbrdf_membership_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_membership_delta_old" ON "dbrdf_membership_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_membership_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 859
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 860
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_medlineplus_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_medlineplus_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27347;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_medlineplus_delta_old" ON "dbrdf_medlineplus_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_medlineplus_delta_old" ON "dbrdf_medlineplus_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_medlineplus_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 861
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_buriedPlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_buriedPlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27348;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_buriedPlace_delta_old" ON "dbrdf_buriedPlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_buriedPlace_delta_old" ON "dbrdf_buriedPlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_buriedPlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 862
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 863
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cargoWater_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cargoWater_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27350;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cargoWater_delta_old0" ON "dbrdf_cargoWater_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_cargoWater_delta_old0" ON "dbrdf_cargoWater_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cargoWater_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/cargoWater$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Spacecraft/cargoWater$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_cargoWater_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_cargoWater_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 = 27350 AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27350, t0.o FROM "dbrdf_cargoWater_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_cargoWater_delta_old0";
        INSERT INTO "dbrdf_cargoWater_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cargoWater_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_cargoWater_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 864
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 865
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 866
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mostPopulousCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mostPopulousCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27353;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mostPopulousCountry_delta_old" ON "dbrdf_mostPopulousCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mostPopulousCountry_delta_old" ON "dbrdf_mostPopulousCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mostPopulousCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 867
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_oldcode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_oldcode_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27354;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_oldcode_delta_old" ON "dbrdf_oldcode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_oldcode_delta_old" ON "dbrdf_oldcode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_oldcode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 868
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_serviceStartYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_serviceStartYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27355;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_serviceStartYear_delta_old" ON "dbrdf_serviceStartYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_serviceStartYear_delta_old" ON "dbrdf_serviceStartYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_serviceStartYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 869
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 870
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_stationStructure_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_stationStructure_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27357;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_stationStructure_delta_old" ON "dbrdf_stationStructure_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_stationStructure_delta_old" ON "dbrdf_stationStructure_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_stationStructure_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 871
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_purpose_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_purpose_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27358;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_purpose_delta_old" ON "dbrdf_purpose_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_purpose_delta_old" ON "dbrdf_purpose_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_purpose_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 872
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstDriverTeam_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstDriverTeam_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27359;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstDriverTeam_delta_old" ON "dbrdf_firstDriverTeam_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstDriverTeam_delta_old" ON "dbrdf_firstDriverTeam_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstDriverTeam_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 873
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_brainInfoType_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_brainInfoType_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27360;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_brainInfoType_delta_old" ON "dbrdf_brainInfoType_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_brainInfoType_delta_old" ON "dbrdf_brainInfoType_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_brainInfoType_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 874
    ---- DEPENDS ON: 873, 815, 743, 133, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Brain>(?X) :- <http://dbpedia.org/ontology/isPartOfAnatomicalStructure>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27361 FROM "__triples" t0 WHERE t0.p = 27227 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27361);
    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_Brain_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Brain_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27361;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Brain_delta_old" ON "dbrdf_Brain_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Brain_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/Brain$delta_new>(?Y) :- <http://dbpedia.org/ontology/Brain$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Brain_delta_new"(s) SELECT t1.o FROM "dbrdf_Brain_delta_old" t0, "__triples" t1 WHERE 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 = 27361);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 875
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_classes_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_classes_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27362;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_classes_delta_old" ON "dbrdf_classes_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_classes_delta_old" ON "dbrdf_classes_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_classes_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 876
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_secretaryGeneral_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_secretaryGeneral_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27363;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_secretaryGeneral_delta_old" ON "dbrdf_secretaryGeneral_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_secretaryGeneral_delta_old" ON "dbrdf_secretaryGeneral_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_secretaryGeneral_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 877
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_animal_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_animal_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27364;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_animal_delta_old" ON "dbrdf_animal_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_animal_delta_old" ON "dbrdf_animal_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_animal_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 878
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_soccerTournamentOpeningSeason_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_soccerTournamentOpeningSeason_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27365;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_soccerTournamentOpeningSeason_delta_old" ON "dbrdf_soccerTournamentOpeningSeason_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_soccerTournamentOpeningSeason_delta_old" ON "dbrdf_soccerTournamentOpeningSeason_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_soccerTournamentOpeningSeason_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 879
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 880
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 881
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_detectionMethod_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_detectionMethod_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27368;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_detectionMethod_delta_old" ON "dbrdf_detectionMethod_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_detectionMethod_delta_old" ON "dbrdf_detectionMethod_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_detectionMethod_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 882
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtProTournaments_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtProTournaments_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27369;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtProTournaments_delta_old" ON "dbrdf_winsAtProTournaments_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtProTournaments_delta_old" ON "dbrdf_winsAtProTournaments_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtProTournaments_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 883
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 884
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 885
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_productionEndDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_productionEndDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27372;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_productionEndDate_delta_old" ON "dbrdf_productionEndDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_productionEndDate_delta_old" ON "dbrdf_productionEndDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_productionEndDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 886
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_careerPrizeMoney_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_careerPrizeMoney_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27373;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_careerPrizeMoney_delta_old" ON "dbrdf_careerPrizeMoney_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_careerPrizeMoney_delta_old" ON "dbrdf_careerPrizeMoney_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_careerPrizeMoney_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 887
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_war_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_war_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27374;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_war_delta_old" ON "dbrdf_war_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_war_delta_old" ON "dbrdf_war_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_war_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 888
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_complexion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_complexion_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27375;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_complexion_delta_old" ON "dbrdf_complexion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_complexion_delta_old" ON "dbrdf_complexion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_complexion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 889
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_speaker_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_speaker_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27376;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_speaker_delta_old" ON "dbrdf_speaker_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_speaker_delta_old" ON "dbrdf_speaker_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_speaker_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 890
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 891
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 892
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_distance_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_distance_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27379;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_distance_delta_old0" ON "dbrdf_distance_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_distance_delta_old0" ON "dbrdf_distance_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_distance_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 893
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_position_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_position_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27380;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_position_delta_old" ON "dbrdf_position_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_position_delta_old" ON "dbrdf_position_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_position_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 894
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_eyeColor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_eyeColor_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27381;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_eyeColor_delta_old" ON "dbrdf_eyeColor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_eyeColor_delta_old" ON "dbrdf_eyeColor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_eyeColor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 895
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_organisationMember_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_organisationMember_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27382;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_organisationMember_delta_old" ON "dbrdf_organisationMember_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_organisationMember_delta_old" ON "dbrdf_organisationMember_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_organisationMember_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 896
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_climate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_climate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27383;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_climate_delta_old" ON "dbrdf_climate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_climate_delta_old" ON "dbrdf_climate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_climate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 897
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_hometown_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_hometown_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27384;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_hometown_delta_old" ON "dbrdf_hometown_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_hometown_delta_old" ON "dbrdf_hometown_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_hometown_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 898
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceConfluenceCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sourceConfluenceCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27385;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sourceConfluenceCountry_delta_old" ON "dbrdf_sourceConfluenceCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sourceConfluenceCountry_delta_old" ON "dbrdf_sourceConfluenceCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceConfluenceCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 899
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 900
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 901
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_length_delta_old3"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_length_delta_old3"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27388;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_length_delta_old3" ON "dbrdf_length_delta_old3"(s, o); CREATE INDEX "IDX_1_dbrdf_length_delta_old3" ON "dbrdf_length_delta_old3"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_length_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/length$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/MeanOfTransportation/length$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_length_delta_new3"(s, o) SELECT t1.o, t0.o FROM "dbrdf_length_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 = 27388 AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27388, t0.o FROM "dbrdf_length_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_length_delta_old3";
        INSERT INTO "dbrdf_length_delta_old3"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_length_delta_new3" t0;
        TRUNCATE TABLE "dbrdf_length_delta_new3";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 902
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mgiid_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mgiid_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27389;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mgiid_delta_old" ON "dbrdf_mgiid_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mgiid_delta_old" ON "dbrdf_mgiid_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mgiid_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 903
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_borough_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_borough_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27390;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_borough_delta_old" ON "dbrdf_borough_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_borough_delta_old" ON "dbrdf_borough_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_borough_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 904
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 905
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cargoFuel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cargoFuel_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27392;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cargoFuel_delta_old" ON "dbrdf_cargoFuel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_cargoFuel_delta_old" ON "dbrdf_cargoFuel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cargoFuel_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 906
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dcc_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dcc_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27393;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dcc_delta_old" ON "dbrdf_dcc_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dcc_delta_old" ON "dbrdf_dcc_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dcc_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 907
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_torchBearer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_torchBearer_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27394;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_torchBearer_delta_old" ON "dbrdf_torchBearer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_torchBearer_delta_old" ON "dbrdf_torchBearer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_torchBearer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 908
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_engineer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_engineer_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27395;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_engineer_delta_old" ON "dbrdf_engineer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_engineer_delta_old" ON "dbrdf_engineer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_engineer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 909
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationDensity_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_populationDensity_delta_old1"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27396;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_populationDensity_delta_old1" ON "dbrdf_populationDensity_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_populationDensity_delta_old1" ON "dbrdf_populationDensity_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationDensity_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/GeopoliticalOrganisation/populationDensity$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/GeopoliticalOrganisation/populationDensity$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_populationDensity_delta_new1"(s, o) SELECT t1.o, t0.o FROM "dbrdf_populationDensity_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 = 27396 AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27396, t0.o FROM "dbrdf_populationDensity_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_populationDensity_delta_old1";
        INSERT INTO "dbrdf_populationDensity_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_populationDensity_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_populationDensity_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 910
    ---- DEPENDS ON: 909, 728, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- [Rule] <http://dbpedia.org/ontology/GeopoliticalOrganisation>(?X) :- <http://dbpedia.org/ontology/GeopoliticalOrganisation/areaMetro>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27397 FROM "__triples" t0 WHERE t0.p = 27212 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27397);
    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_GeopoliticalOrganisation_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_GeopoliticalOrganisation_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27397;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_GeopoliticalOrganisation_delta_old" ON "dbrdf_GeopoliticalOrganisation_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_GeopoliticalOrganisation_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/GeopoliticalOrganisation$delta_new>(?Y) :- <http://dbpedia.org/ontology/GeopoliticalOrganisation$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_GeopoliticalOrganisation_delta_new"(s) SELECT t1.o FROM "dbrdf_GeopoliticalOrganisation_delta_old" t0, "__triples" t1 WHERE 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 = 27397);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 911
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_soccerTournamentThisSeason_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_soccerTournamentThisSeason_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27398;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_soccerTournamentThisSeason_delta_old" ON "dbrdf_soccerTournamentThisSeason_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_soccerTournamentThisSeason_delta_old" ON "dbrdf_soccerTournamentThisSeason_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_soccerTournamentThisSeason_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 912
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_gaudiAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_gaudiAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27399;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_gaudiAward_delta_old" ON "dbrdf_gaudiAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_gaudiAward_delta_old" ON "dbrdf_gaudiAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_gaudiAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 913
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_film_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_film_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27400;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_film_delta_old" ON "dbrdf_film_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_film_delta_old" ON "dbrdf_film_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_film_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 914
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 915
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_absoluteMagnitude_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_absoluteMagnitude_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27402;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_absoluteMagnitude_delta_old" ON "dbrdf_absoluteMagnitude_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_absoluteMagnitude_delta_old" ON "dbrdf_absoluteMagnitude_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_absoluteMagnitude_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 916
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 917
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_chairmanTitle_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_chairmanTitle_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27404;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_chairmanTitle_delta_old" ON "dbrdf_chairmanTitle_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_chairmanTitle_delta_old" ON "dbrdf_chairmanTitle_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_chairmanTitle_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 918
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_squadNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_squadNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27405;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_squadNumber_delta_old" ON "dbrdf_squadNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_squadNumber_delta_old" ON "dbrdf_squadNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_squadNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 919
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_domain_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_domain_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27406;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_domain_delta_old" ON "dbrdf_domain_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_domain_delta_old" ON "dbrdf_domain_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_domain_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 920
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_totalTracks_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_totalTracks_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27407;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_totalTracks_delta_old" ON "dbrdf_totalTracks_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_totalTracks_delta_old" ON "dbrdf_totalTracks_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_totalTracks_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 921
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_richestCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_richestCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27408;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_richestCountry_delta_old" ON "dbrdf_richestCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_richestCountry_delta_old" ON "dbrdf_richestCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_richestCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 922
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_shipDraft_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_shipDraft_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27409;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_shipDraft_delta_old" ON "dbrdf_shipDraft_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_shipDraft_delta_old" ON "dbrdf_shipDraft_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_shipDraft_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 923
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_otherAppearances_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_otherAppearances_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27410;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_otherAppearances_delta_old" ON "dbrdf_otherAppearances_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_otherAppearances_delta_old" ON "dbrdf_otherAppearances_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_otherAppearances_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 924
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_soocerLeagueSeason_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_soocerLeagueSeason_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27411;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_soocerLeagueSeason_delta_old" ON "dbrdf_soocerLeagueSeason_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_soocerLeagueSeason_delta_old" ON "dbrdf_soocerLeagueSeason_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_soocerLeagueSeason_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 925
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 926
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_hasNaturalBust_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_hasNaturalBust_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27413;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_hasNaturalBust_delta_old" ON "dbrdf_hasNaturalBust_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_hasNaturalBust_delta_old" ON "dbrdf_hasNaturalBust_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_hasNaturalBust_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 927
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 928
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rgbCoordinateBlue_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rgbCoordinateBlue_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27415;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rgbCoordinateBlue_delta_old" ON "dbrdf_rgbCoordinateBlue_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rgbCoordinateBlue_delta_old" ON "dbrdf_rgbCoordinateBlue_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rgbCoordinateBlue_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 929
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_diameter_delta_old2"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_diameter_delta_old2"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27416;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_diameter_delta_old2" ON "dbrdf_diameter_delta_old2"(s, o); CREATE INDEX "IDX_1_dbrdf_diameter_delta_old2" ON "dbrdf_diameter_delta_old2"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_diameter_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/LunarCrater/diameter$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/LunarCrater/diameter$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_diameter_delta_new2"(s, o) SELECT t1.o, t0.o FROM "dbrdf_diameter_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 = 27416 AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27416, t0.o FROM "dbrdf_diameter_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_diameter_delta_old2";
        INSERT INTO "dbrdf_diameter_delta_old2"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_diameter_delta_new2" t0;
        TRUNCATE TABLE "dbrdf_diameter_delta_new2";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 930
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumInclination_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_maximumInclination_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27417;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_maximumInclination_delta_old" ON "dbrdf_maximumInclination_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_maximumInclination_delta_old" ON "dbrdf_maximumInclination_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumInclination_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 931
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_popularVote_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_popularVote_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27418;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_popularVote_delta_old" ON "dbrdf_popularVote_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_popularVote_delta_old" ON "dbrdf_popularVote_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_popularVote_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 932
    ---- DEPENDS ON: 931, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Election>(?X) :- <http://dbpedia.org/ontology/popularVote>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27419 FROM "__triples" t0 WHERE t0.p = 27418 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27419);
    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_Election_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Election_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27419;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Election_delta_old" ON "dbrdf_Election_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Election_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/Election$delta_new>(?Y) :- <http://dbpedia.org/ontology/Election$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Election_delta_new"(s) SELECT t1.o FROM "dbrdf_Election_delta_old" t0, "__triples" t1 WHERE 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 = 27419);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 933
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 934
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_draftRound_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_draftRound_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27421;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_draftRound_delta_old" ON "dbrdf_draftRound_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_draftRound_delta_old" ON "dbrdf_draftRound_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_draftRound_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 935
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_meetingRoad_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_meetingRoad_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27422;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_meetingRoad_delta_old" ON "dbrdf_meetingRoad_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_meetingRoad_delta_old" ON "dbrdf_meetingRoad_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_meetingRoad_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 936
    ---- DEPENDS ON: 935, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/RoadJunction>(?X) :- <http://dbpedia.org/ontology/meetingRoad>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27423 FROM "__triples" t0 WHERE t0.p = 27422 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27423);
    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_RoadJunction_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_RoadJunction_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27423;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_RoadJunction_delta_old" ON "dbrdf_RoadJunction_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_RoadJunction_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/RoadJunction$delta_new>(?Y) :- <http://dbpedia.org/ontology/RoadJunction$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_RoadJunction_delta_new"(s) SELECT t1.o FROM "dbrdf_RoadJunction_delta_old" t0, "__triples" t1 WHERE 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 = 27423);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 937
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 938
    ---- DEPENDS ON: 615, 0
    ----------------------------------------

    -- Nonrecursive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 939
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_parent_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_parent_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27426;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_parent_delta_old" ON "dbrdf_parent_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_parent_delta_old" ON "dbrdf_parent_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_parent_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 940
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27427, t0.o FROM "dbrdf_areaMetro_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_areaMetro_delta_old1";
        INSERT INTO "dbrdf_areaMetro_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_areaMetro_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_areaMetro_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 941
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mayor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mayor_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27428;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mayor_delta_old" ON "dbrdf_mayor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mayor_delta_old" ON "dbrdf_mayor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mayor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 942
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 943
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 944
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 945
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 946
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_electionDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_electionDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27433;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_electionDate_delta_old" ON "dbrdf_electionDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_electionDate_delta_old" ON "dbrdf_electionDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_electionDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 947
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dissolutionYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dissolutionYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27434;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dissolutionYear_delta_old" ON "dbrdf_dissolutionYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dissolutionYear_delta_old" ON "dbrdf_dissolutionYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dissolutionYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 948
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 949
    ---- DEPENDS ON: 948, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/ProtectedArea>(?X) :- <http://dbpedia.org/ontology/iucnCategory>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27436 FROM "__triples" t0 WHERE t0.p = 27435 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27436);
    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_ProtectedArea_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ProtectedArea_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27436;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ProtectedArea_delta_old" ON "dbrdf_ProtectedArea_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ProtectedArea_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/ProtectedArea$delta_new>(?Y) :- <http://dbpedia.org/ontology/ProtectedArea$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_ProtectedArea_delta_new"(s) SELECT t1.o FROM "dbrdf_ProtectedArea_delta_old" t0, "__triples" t1 WHERE 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 = 27436);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 950
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_orbitalFlights_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_orbitalFlights_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27437;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_orbitalFlights_delta_old" ON "dbrdf_orbitalFlights_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_orbitalFlights_delta_old" ON "dbrdf_orbitalFlights_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_orbitalFlights_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 951
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 952
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastLaunchDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lastLaunchDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27439;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lastLaunchDate_delta_old" ON "dbrdf_lastLaunchDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lastLaunchDate_delta_old" ON "dbrdf_lastLaunchDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastLaunchDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 953
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 954
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_creativeDirector_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_creativeDirector_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27441;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_creativeDirector_delta_old" ON "dbrdf_creativeDirector_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_creativeDirector_delta_old" ON "dbrdf_creativeDirector_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_creativeDirector_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 955
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_gun_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_gun_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27442;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_gun_delta_old" ON "dbrdf_gun_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_gun_delta_old" ON "dbrdf_gun_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_gun_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 956
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mostPopulatedCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mostPopulatedCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27443;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mostPopulatedCountry_delta_old" ON "dbrdf_mostPopulatedCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mostPopulatedCountry_delta_old" ON "dbrdf_mostPopulatedCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mostPopulatedCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 957
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_regionalLanguage_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_regionalLanguage_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27444;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_regionalLanguage_delta_old" ON "dbrdf_regionalLanguage_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_regionalLanguage_delta_old" ON "dbrdf_regionalLanguage_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_regionalLanguage_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 958
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 959
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_largestCity_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_largestCity_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27446;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_largestCity_delta_old" ON "dbrdf_largestCity_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_largestCity_delta_old" ON "dbrdf_largestCity_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_largestCity_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 960
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_programmeFormat_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_programmeFormat_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27447;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_programmeFormat_delta_old" ON "dbrdf_programmeFormat_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_programmeFormat_delta_old" ON "dbrdf_programmeFormat_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_programmeFormat_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 961
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 962
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_denomination_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_denomination_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27449;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_denomination_delta_old" ON "dbrdf_denomination_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_denomination_delta_old" ON "dbrdf_denomination_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_denomination_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 963
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ecNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ecNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27450;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ecNumber_delta_old" ON "dbrdf_ecNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ecNumber_delta_old" ON "dbrdf_ecNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ecNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 964
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 965
    ---- DEPENDS ON: 964, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 966
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 967
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_splitFromParty_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_splitFromParty_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27454;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_splitFromParty_delta_old" ON "dbrdf_splitFromParty_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_splitFromParty_delta_old" ON "dbrdf_splitFromParty_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_splitFromParty_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 968
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberBuilt_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberBuilt_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27455;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberBuilt_delta_old" ON "dbrdf_numberBuilt_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberBuilt_delta_old" ON "dbrdf_numberBuilt_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberBuilt_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 969
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dorlandsSuffix_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dorlandsSuffix_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27456;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dorlandsSuffix_delta_old" ON "dbrdf_dorlandsSuffix_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dorlandsSuffix_delta_old" ON "dbrdf_dorlandsSuffix_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dorlandsSuffix_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 970
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_demolitionDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_demolitionDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27457;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_demolitionDate_delta_old" ON "dbrdf_demolitionDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_demolitionDate_delta_old" ON "dbrdf_demolitionDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_demolitionDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 971
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_specialEffects_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_specialEffects_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27458;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_specialEffects_delta_old" ON "dbrdf_specialEffects_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_specialEffects_delta_old" ON "dbrdf_specialEffects_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_specialEffects_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 972
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winterAppearances_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winterAppearances_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27459;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winterAppearances_delta_old" ON "dbrdf_winterAppearances_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winterAppearances_delta_old" ON "dbrdf_winterAppearances_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winterAppearances_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 973
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 974
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dateClosed_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dateClosed_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27461;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dateClosed_delta_old" ON "dbrdf_dateClosed_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dateClosed_delta_old" ON "dbrdf_dateClosed_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dateClosed_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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