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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1503
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1504
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Nonrecursive rules

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

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Scientist_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Scientist_delta_old"(s) SELECT t0.s FROM "dbrdf_Scientist" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Scientist_delta_old" ON "dbrdf_Scientist_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Scientist_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Scientist"(s) SELECT DISTINCT t0.s FROM "dbrdf_Scientist_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Scientist_delta_old";
        INSERT INTO "dbrdf_Scientist_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Scientist_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Scientist_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1508
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1509
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1515
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Decoration_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Decoration_delta_old"(s) SELECT t0.s FROM "dbrdf_Decoration" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Decoration_delta_old" ON "dbrdf_Decoration_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Decoration_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Decoration"(s) SELECT DISTINCT t0.s FROM "dbrdf_Decoration_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Decoration_delta_old";
        INSERT INTO "dbrdf_Decoration_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Decoration_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Decoration_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1516
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1517
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1518
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1521
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1522
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1524
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1525
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_port1DockedTime_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_port1DockedTime_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_port1DockedTime0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_port1DockedTime_delta_old0" ON "dbrdf_port1DockedTime_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_port1DockedTime_delta_old0" ON "dbrdf_port1DockedTime_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_port1DockedTime_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1527
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1528
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1529
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1532
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1533
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1534
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1536
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1537
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1538
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaTotal_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_areaTotal_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_areaTotal0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_areaTotal_delta_old0" ON "dbrdf_areaTotal_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_areaTotal_delta_old0" ON "dbrdf_areaTotal_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaTotal_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1543
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1544
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1547
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1548
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Nonrecursive rules

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Currency_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Currency_delta_old"(s) SELECT t0.s FROM "dbrdf_Currency" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Currency_delta_old" ON "dbrdf_Currency_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Currency_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Currency"(s) SELECT DISTINCT t0.s FROM "dbrdf_Currency_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Currency_delta_old";
        INSERT INTO "dbrdf_Currency_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Currency_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Currency_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1553
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1554
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumBoatLength_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_maximumBoatLength_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_maximumBoatLength0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_maximumBoatLength_delta_old0" ON "dbrdf_maximumBoatLength_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_maximumBoatLength_delta_old0" ON "dbrdf_maximumBoatLength_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumBoatLength_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1560
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1561
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1562
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1563
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1564
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1565
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1566
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_AmericanFootballPlayer_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_AmericanFootballPlayer_delta_old"(s) SELECT t0.s FROM "dbrdf_AmericanFootballPlayer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_AmericanFootballPlayer_delta_old" ON "dbrdf_AmericanFootballPlayer_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_AmericanFootballPlayer_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_AmericanFootballPlayer"(s) SELECT DISTINCT t0.s FROM "dbrdf_AmericanFootballPlayer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_AmericanFootballPlayer_delta_old";
        INSERT INTO "dbrdf_AmericanFootballPlayer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_AmericanFootballPlayer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_AmericanFootballPlayer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1567
    ---- DEPENDS ON: 1566, 1391, 1110, 1077, 934, 580, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/GridironFootballPlayer>(?X) :- <http://dbpedia.org/ontology/AmericanFootballPlayer>(?X) .
    INSERT INTO "dbrdf_GridironFootballPlayer"(s) SELECT t0.s FROM "dbrdf_AmericanFootballPlayer" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_GridironFootballPlayer" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

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

    -- [Rule] <http://dbpedia.org/ontology/GridironFootballPlayer>(?X) :- <http://dbpedia.org/ontology/CanadianFootballPlayer>(?X) .
    INSERT INTO "dbrdf_GridironFootballPlayer"(s) SELECT t0.s FROM "dbrdf_CanadianFootballPlayer" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_GridironFootballPlayer" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_GridironFootballPlayer_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_GridironFootballPlayer_delta_old"(s) SELECT t0.s FROM "dbrdf_GridironFootballPlayer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_GridironFootballPlayer_delta_old" ON "dbrdf_GridironFootballPlayer_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_GridironFootballPlayer_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_GridironFootballPlayer"(s) SELECT DISTINCT t0.s FROM "dbrdf_GridironFootballPlayer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_GridironFootballPlayer_delta_old";
        INSERT INTO "dbrdf_GridironFootballPlayer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_GridironFootballPlayer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_GridironFootballPlayer_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1569
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Cycad_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Cycad_delta_old"(s) SELECT t0.s FROM "dbrdf_Cycad" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Cycad_delta_old" ON "dbrdf_Cycad_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Cycad_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Cycad"(s) SELECT DISTINCT t0.s FROM "dbrdf_Cycad_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Cycad_delta_old";
        INSERT INTO "dbrdf_Cycad_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Cycad_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Cycad_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1570
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Nonrecursive rules

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_SpaceStation_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SpaceStation_delta_old"(s) SELECT t0.s FROM "dbrdf_SpaceStation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SpaceStation_delta_old" ON "dbrdf_SpaceStation_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SpaceStation_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_SpaceStation"(s) SELECT DISTINCT t0.s FROM "dbrdf_SpaceStation_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SpaceStation_delta_old";
        INSERT INTO "dbrdf_SpaceStation_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SpaceStation_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SpaceStation_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_AmericanFootballTeam_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_AmericanFootballTeam_delta_old"(s) SELECT t0.s FROM "dbrdf_AmericanFootballTeam" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_AmericanFootballTeam_delta_old" ON "dbrdf_AmericanFootballTeam_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_AmericanFootballTeam_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_AmericanFootballTeam"(s) SELECT DISTINCT t0.s FROM "dbrdf_AmericanFootballTeam_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_AmericanFootballTeam_delta_old";
        INSERT INTO "dbrdf_AmericanFootballTeam_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_AmericanFootballTeam_delta_new" t0;
        TRUNCATE TABLE "dbrdf_AmericanFootballTeam_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Ginkgo_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Ginkgo_delta_old"(s) SELECT t0.s FROM "dbrdf_Ginkgo" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Ginkgo_delta_old" ON "dbrdf_Ginkgo_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Ginkgo_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Ginkgo"(s) SELECT DISTINCT t0.s FROM "dbrdf_Ginkgo_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Ginkgo_delta_old";
        INSERT INTO "dbrdf_Ginkgo_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Ginkgo_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Ginkgo_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1579
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1580
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1581
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1582
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1583
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1585
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1586
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1587
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Nonrecursive rules

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

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

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

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

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ResearchProject_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ResearchProject_delta_old"(s) SELECT t0.s FROM "dbrdf_ResearchProject" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ResearchProject_delta_old" ON "dbrdf_ResearchProject_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ResearchProject_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_ResearchProject"(s) SELECT DISTINCT t0.s FROM "dbrdf_ResearchProject_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_ResearchProject_delta_old";
        INSERT INTO "dbrdf_ResearchProject_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_ResearchProject_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ResearchProject_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Legislature_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Legislature_delta_old"(s) SELECT t0.s FROM "dbrdf_Legislature" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Legislature_delta_old" ON "dbrdf_Legislature_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Legislature_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Legislature"(s) SELECT DISTINCT t0.s FROM "dbrdf_Legislature_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Legislature_delta_old";
        INSERT INTO "dbrdf_Legislature_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Legislature_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Legislature_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1595
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1596
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Nonrecursive rules

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Race_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Race_delta_old"(s) SELECT t0.s FROM "dbrdf_Race" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Race_delta_old" ON "dbrdf_Race_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Race_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Race"(s) SELECT DISTINCT t0.s FROM "dbrdf_Race_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Race_delta_old";
        INSERT INTO "dbrdf_Race_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Race_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Race_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_apoapsis_delta_old2"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_apoapsis_delta_old2"(s, o) SELECT t0.s, t0.o FROM "dbrdf_apoapsis2" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_apoapsis_delta_old2" ON "dbrdf_apoapsis_delta_old2"(s, o); CREATE INDEX "IDX_1_dbrdf_apoapsis_delta_old2" ON "dbrdf_apoapsis_delta_old2"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_apoapsis_delta_new2"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Nonrecursive rules

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

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

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

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Olympics_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Olympics_delta_old"(s) SELECT t0.s FROM "dbrdf_Olympics" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Olympics_delta_old" ON "dbrdf_Olympics_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Olympics_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Olympics"(s) SELECT DISTINCT t0.s FROM "dbrdf_Olympics_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Olympics_delta_old";
        INSERT INTO "dbrdf_Olympics_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Olympics_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Olympics_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_SpatialThing_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SpatialThing_delta_old"(s) SELECT t0.s FROM "dbrdf_SpatialThing" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SpatialThing_delta_old" ON "dbrdf_SpatialThing_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SpatialThing_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://www.w3.org/2003/01/geo/wgs84_pos#SpatialThing$delta_new>(?Y) :- <http://www.w3.org/2003/01/geo/wgs84_pos#SpatialThing$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_SpatialThing_delta_new"(s) SELECT t1.o FROM "dbrdf_SpatialThing_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_SpatialThing" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_SpatialThing"(s) SELECT DISTINCT t0.s FROM "dbrdf_SpatialThing_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SpatialThing_delta_old";
        INSERT INTO "dbrdf_SpatialThing_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SpatialThing_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SpatialThing_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1610
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1611
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1617
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1618
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Bacteria_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Bacteria_delta_old"(s) SELECT t0.s FROM "dbrdf_Bacteria" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Bacteria_delta_old" ON "dbrdf_Bacteria_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Bacteria_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Bacteria"(s) SELECT DISTINCT t0.s FROM "dbrdf_Bacteria_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Bacteria_delta_old";
        INSERT INTO "dbrdf_Bacteria_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Bacteria_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Bacteria_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1619
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1620
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_AmericanFootballLeague_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_AmericanFootballLeague_delta_old"(s) SELECT t0.s FROM "dbrdf_AmericanFootballLeague" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_AmericanFootballLeague_delta_old" ON "dbrdf_AmericanFootballLeague_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_AmericanFootballLeague_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_AmericanFootballLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_AmericanFootballLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_AmericanFootballLeague_delta_old";
        INSERT INTO "dbrdf_AmericanFootballLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_AmericanFootballLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_AmericanFootballLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1621
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Nonrecursive rules

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_AdministrativeArea_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_AdministrativeArea_delta_old"(s) SELECT t0.s FROM "dbrdf_AdministrativeArea" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_AdministrativeArea_delta_old" ON "dbrdf_AdministrativeArea_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_AdministrativeArea_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_AdministrativeRegion_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_AdministrativeRegion_delta_old"(s) SELECT t0.s FROM "dbrdf_AdministrativeRegion" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_AdministrativeRegion_delta_old" ON "dbrdf_AdministrativeRegion_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_AdministrativeRegion_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- <http://schema.org/AdministrativeArea$delta_new>(?Y) :- <http://schema.org/AdministrativeArea$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_AdministrativeArea_delta_new"(s) SELECT t1.o FROM "dbrdf_AdministrativeArea_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_AdministrativeArea" ex WHERE ex.s = t1.o);


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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_AdministrativeArea"(s) SELECT DISTINCT t0.s FROM "dbrdf_AdministrativeArea_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_AdministrativeArea_delta_old";
        INSERT INTO "dbrdf_AdministrativeArea_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_AdministrativeArea_delta_new" t0;
        TRUNCATE TABLE "dbrdf_AdministrativeArea_delta_new";

        INSERT INTO "dbrdf_AdministrativeRegion"(s) SELECT DISTINCT t0.s FROM "dbrdf_AdministrativeRegion_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_AdministrativeRegion_delta_old";
        INSERT INTO "dbrdf_AdministrativeRegion_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_AdministrativeRegion_delta_new" t0;
        TRUNCATE TABLE "dbrdf_AdministrativeRegion_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1623
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_pastor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_pastor_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_pastor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_pastor_delta_old" ON "dbrdf_pastor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_pastor_delta_old" ON "dbrdf_pastor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_pastor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1624
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_formationDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_formationDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_formationDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_formationDate_delta_old" ON "dbrdf_formationDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_formationDate_delta_old" ON "dbrdf_formationDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_formationDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1625
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_agencyStationCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_agencyStationCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_agencyStationCode" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_agencyStationCode_delta_old" ON "dbrdf_agencyStationCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_agencyStationCode_delta_old" ON "dbrdf_agencyStationCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_agencyStationCode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1626
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1627
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lessPopulatedCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lessPopulatedCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lessPopulatedCountry" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lessPopulatedCountry_delta_old" ON "dbrdf_lessPopulatedCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lessPopulatedCountry_delta_old" ON "dbrdf_lessPopulatedCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lessPopulatedCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1628
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1629
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1630
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_weight3"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_weight_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_weight_delta_old3";
        INSERT INTO "dbrdf_weight_delta_old3"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_weight_delta_new3" t0;
        TRUNCATE TABLE "dbrdf_weight_delta_new3";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1631
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1632
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1633
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1634
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1635
    ---- DEPENDS ON: 1634, 943, 920, 664, 264, 88, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Album>(?X1) :- <http://dbpedia.org/ontology/album>(?X,?X1) .
    INSERT INTO "dbrdf_Album"(s) SELECT DISTINCT t0.o FROM "dbrdf_album" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Album" ex WHERE ex.s = t0.o);
    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_MusicAlbum_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_MusicAlbum_delta_old"(s) SELECT t0.s FROM "dbrdf_MusicAlbum" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_MusicAlbum_delta_old" ON "dbrdf_MusicAlbum_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_MusicAlbum_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Album_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Album_delta_old"(s) SELECT t0.s FROM "dbrdf_Album" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Album_delta_old" ON "dbrdf_Album_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Album_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://schema.org/MusicAlbum$delta_new>(?X) :- <http://dbpedia.org/ontology/Album$delta_old>(?X) .
        INSERT INTO "dbrdf_MusicAlbum_delta_new"(s) SELECT t0.s FROM "dbrdf_Album_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_MusicAlbum" ex WHERE ex.s = t0.s);


        -- <http://schema.org/MusicAlbum$delta_new>(?Y) :- <http://schema.org/MusicAlbum$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_MusicAlbum_delta_new"(s) SELECT t1.o FROM "dbrdf_MusicAlbum_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_MusicAlbum" ex WHERE ex.s = t1.o);


        -- <http://dbpedia.org/ontology/Album$delta_new>(?X) :- <http://schema.org/MusicAlbum$delta_old>(?X) .
        INSERT INTO "dbrdf_Album_delta_new"(s) SELECT t0.s FROM "dbrdf_MusicAlbum_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Album" ex WHERE ex.s = t0.s);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_MusicAlbum"(s) SELECT DISTINCT t0.s FROM "dbrdf_MusicAlbum_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_MusicAlbum_delta_old";
        INSERT INTO "dbrdf_MusicAlbum_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_MusicAlbum_delta_new" t0;
        TRUNCATE TABLE "dbrdf_MusicAlbum_delta_new";

        INSERT INTO "dbrdf_Album"(s) SELECT DISTINCT t0.s FROM "dbrdf_Album_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Album_delta_old";
        INSERT INTO "dbrdf_Album_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Album_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Album_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1636
    ---- DEPENDS ON: 1635, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://schema.org/MusicAlbumR>(?X,?X) :- <http://schema.org/MusicAlbum>(?X) .
    INSERT INTO "dbrdf_MusicAlbumR"(s, o) SELECT DISTINCT t0.s, t0.s FROM "dbrdf_MusicAlbum" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_MusicAlbumR" ex WHERE ex.s = t0.s AND ex.o = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_MusicAlbumR_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_MusicAlbumR_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_MusicAlbumR" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_MusicAlbumR_delta_old" ON "dbrdf_MusicAlbumR_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_MusicAlbumR_delta_old" ON "dbrdf_MusicAlbumR_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_MusicAlbumR_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://schema.org/MusicAlbumR$delta_new>(?Y,?X1) :- <http://schema.org/MusicAlbumR$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_MusicAlbumR_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_MusicAlbumR_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_MusicAlbumR" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://schema.org/MusicAlbumR$delta_new>(?X0,?Y) :- <http://schema.org/MusicAlbumR$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_MusicAlbumR_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_MusicAlbumR_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_MusicAlbumR" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1637
    ---- DEPENDS ON: 1494, 1493, 1636, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/albumHasGenre>(?X0,?X3) :- <http://schema.org/MusicAlbumR>(?X0,?X1), <http://dbpedia.org/ontology/genre>(?X1,?X2), <http://dbpedia.org/ontology/MusicGenreR>(?X2,?X3) .
    INSERT INTO "dbrdf_albumHasGenre"(s, o) SELECT DISTINCT t0.s, t2.o FROM "dbrdf_MusicAlbumR" t0, "dbrdf_genre" t1, "dbrdf_MusicGenreR" t2 WHERE t0.o = t1.s AND t1.o = t2.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_albumHasGenre" ex WHERE ex.s = t0.s AND ex.o = t2.o);
    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_albumHasGenre_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_albumHasGenre_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_albumHasGenre" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_albumHasGenre_delta_old" ON "dbrdf_albumHasGenre_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_albumHasGenre_delta_old" ON "dbrdf_albumHasGenre_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_albumHasGenre_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1638
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_latestPreviewVersion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_latestPreviewVersion_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_latestPreviewVersion" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_latestPreviewVersion_delta_old" ON "dbrdf_latestPreviewVersion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_latestPreviewVersion_delta_old" ON "dbrdf_latestPreviewVersion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_latestPreviewVersion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1639
    ---- DEPENDS ON: 171, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_GivenName"(s) SELECT DISTINCT t0.s FROM "dbrdf_GivenName_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_GivenName_delta_old";
        INSERT INTO "dbrdf_GivenName_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_GivenName_delta_new" t0;
        TRUNCATE TABLE "dbrdf_GivenName_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1640
    ---- DEPENDS ON: 1639, 1286, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Name>(?X) :- <http://dbpedia.org/ontology/GivenName>(?X) .
    INSERT INTO "dbrdf_Name"(s) SELECT t0.s FROM "dbrdf_GivenName" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Name" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/Name>(?X) :- <http://dbpedia.org/ontology/Surname>(?X) .
    INSERT INTO "dbrdf_Name"(s) SELECT t0.s FROM "dbrdf_Surname" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Name" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Name"(s) SELECT DISTINCT t0.s FROM "dbrdf_Name_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Name_delta_old";
        INSERT INTO "dbrdf_Name_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Name_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Name_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1641
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lieutenancyArea_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lieutenancyArea_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lieutenancyArea" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lieutenancyArea_delta_old" ON "dbrdf_lieutenancyArea_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lieutenancyArea_delta_old" ON "dbrdf_lieutenancyArea_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lieutenancyArea_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1642
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_guest_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_guest_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_guest" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_guest_delta_old" ON "dbrdf_guest_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_guest_delta_old" ON "dbrdf_guest_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_guest_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1643
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_managementRegion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_managementRegion_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_managementRegion" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_managementRegion_delta_old" ON "dbrdf_managementRegion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_managementRegion_delta_old" ON "dbrdf_managementRegion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_managementRegion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1644
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_effectiveRadiatedPower_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_effectiveRadiatedPower_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_effectiveRadiatedPower" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_effectiveRadiatedPower_delta_old" ON "dbrdf_effectiveRadiatedPower_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_effectiveRadiatedPower_delta_old" ON "dbrdf_effectiveRadiatedPower_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_effectiveRadiatedPower_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1645
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1646
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_seniority_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_seniority_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_seniority" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_seniority_delta_old" ON "dbrdf_seniority_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_seniority_delta_old" ON "dbrdf_seniority_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_seniority_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1647
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_campus_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_campus_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_campus" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_campus_delta_old" ON "dbrdf_campus_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_campus_delta_old" ON "dbrdf_campus_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_campus_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1648
    ---- DEPENDS ON: 1647, 1591, 1068, 1013, 520, 415, 321, 223, 107, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_College_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_College_delta_old"(s) SELECT t0.s FROM "dbrdf_College" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_College_delta_old" ON "dbrdf_College_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_College_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_CollegeOrUniversity_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_CollegeOrUniversity_delta_old"(s) SELECT t0.s FROM "dbrdf_CollegeOrUniversity" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_CollegeOrUniversity_delta_old" ON "dbrdf_CollegeOrUniversity_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_CollegeOrUniversity_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_University_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_University_delta_old"(s) SELECT t0.s FROM "dbrdf_University0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_University_delta_old" ON "dbrdf_University_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_University_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/College$delta_new>(?X) :- <http://schema.org/CollegeOrUniversity$delta_old>(?X) .
        INSERT INTO "dbrdf_College_delta_new"(s) SELECT t0.s FROM "dbrdf_CollegeOrUniversity_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_College" ex WHERE ex.s = t0.s);


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


        -- <http://schema.org/CollegeOrUniversity$delta_new>(?X) :- <http://dbpedia.org/ontology/University$delta_old>(?X) .
        INSERT INTO "dbrdf_CollegeOrUniversity_delta_new"(s) SELECT t0.s FROM "dbrdf_University_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_CollegeOrUniversity" ex WHERE ex.s = t0.s);


        -- <http://schema.org/CollegeOrUniversity$delta_new>(?X) :- <http://dbpedia.org/ontology/College$delta_old>(?X) .
        INSERT INTO "dbrdf_CollegeOrUniversity_delta_new"(s) SELECT t0.s FROM "dbrdf_College_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_CollegeOrUniversity" ex WHERE ex.s = t0.s);


        -- <http://schema.org/CollegeOrUniversity$delta_new>(?Y) :- <http://schema.org/CollegeOrUniversity$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_CollegeOrUniversity_delta_new"(s) SELECT t1.o FROM "dbrdf_CollegeOrUniversity_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_CollegeOrUniversity" ex WHERE ex.s = t1.o);


        -- <http://dbpedia.org/ontology/University$delta_new>(?X) :- <http://schema.org/CollegeOrUniversity$delta_old>(?X) .
        INSERT INTO "dbrdf_University_delta_new"(s) SELECT t0.s FROM "dbrdf_CollegeOrUniversity_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_University0" ex WHERE ex.s = t0.s);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_College"(s) SELECT DISTINCT t0.s FROM "dbrdf_College_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_College_delta_old";
        INSERT INTO "dbrdf_College_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_College_delta_new" t0;
        TRUNCATE TABLE "dbrdf_College_delta_new";

        INSERT INTO "dbrdf_CollegeOrUniversity"(s) SELECT DISTINCT t0.s FROM "dbrdf_CollegeOrUniversity_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_CollegeOrUniversity_delta_old";
        INSERT INTO "dbrdf_CollegeOrUniversity_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_CollegeOrUniversity_delta_new" t0;
        TRUNCATE TABLE "dbrdf_CollegeOrUniversity_delta_new";

        INSERT INTO "dbrdf_University0"(s) SELECT DISTINCT t0.s FROM "dbrdf_University_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_University_delta_old";
        INSERT INTO "dbrdf_University_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_University_delta_new" t0;
        TRUNCATE TABLE "dbrdf_University_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1649
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_decommissioningDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_decommissioningDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_decommissioningDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_decommissioningDate_delta_old" ON "dbrdf_decommissioningDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_decommissioningDate_delta_old" ON "dbrdf_decommissioningDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_decommissioningDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1650
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_riverMouth_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_riverMouth_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_riverMouth" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_riverMouth_delta_old" ON "dbrdf_riverMouth_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_riverMouth_delta_old" ON "dbrdf_riverMouth_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_riverMouth_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1651
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_minimumDischarge0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_minimumDischarge_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_minimumDischarge_delta_old0";
        INSERT INTO "dbrdf_minimumDischarge_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_minimumDischarge_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_minimumDischarge_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1652
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lunarLandingSite_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lunarLandingSite_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lunarLandingSite" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lunarLandingSite_delta_old" ON "dbrdf_lunarLandingSite_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lunarLandingSite_delta_old" ON "dbrdf_lunarLandingSite_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lunarLandingSite_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1653
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_visitorsPercentageChange_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_visitorsPercentageChange_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_visitorsPercentageChange" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_visitorsPercentageChange_delta_old" ON "dbrdf_visitorsPercentageChange_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_visitorsPercentageChange_delta_old" ON "dbrdf_visitorsPercentageChange_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_visitorsPercentageChange_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1654
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1655
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_diameter3"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_diameter_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_diameter_delta_old3";
        INSERT INTO "dbrdf_diameter_delta_old3"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_diameter_delta_new3" t0;
        TRUNCATE TABLE "dbrdf_diameter_delta_new3";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1656
    ---- DEPENDS ON: 1655, 1630, 1087, 487, 334, 72, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Weapon"(s) SELECT DISTINCT t0.s FROM "dbrdf_Weapon_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Weapon_delta_old";
        INSERT INTO "dbrdf_Weapon_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Weapon_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Weapon_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1657
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_casSupplemental_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_casSupplemental_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_casSupplemental" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_casSupplemental_delta_old" ON "dbrdf_casSupplemental_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_casSupplemental_delta_old" ON "dbrdf_casSupplemental_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_casSupplemental_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1658
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1659
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_baftaAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_baftaAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_baftaAward" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_baftaAward_delta_old" ON "dbrdf_baftaAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_baftaAward_delta_old" ON "dbrdf_baftaAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_baftaAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1660
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

