    CREATE LOCAL TEMPORARY TABLE "dbrdf_period_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_SoccerClubSeason_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SoccerClubSeason_delta_old"(s) SELECT t0.s FROM "dbrdf_SoccerClubSeason" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SoccerClubSeason_delta_old" ON "dbrdf_SoccerClubSeason_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SoccerClubSeason_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_SoccerClubSeason"(s) SELECT DISTINCT t0.s FROM "dbrdf_SoccerClubSeason_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SoccerClubSeason_delta_old";
        INSERT INTO "dbrdf_SoccerClubSeason_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SoccerClubSeason_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SoccerClubSeason_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_coProducer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_coProducer_delta_old"(s, o) SELECT t0.s, t0.o FROM "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 518
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_unitedStatesNationalBridgeId_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_unitedStatesNationalBridgeId_delta_old"(s, o) SELECT t0.s, t0.o FROM "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 519
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dryCargo_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dryCargo_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_dryCargo" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dryCargo_delta_old" ON "dbrdf_dryCargo_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dryCargo_delta_old" ON "dbrdf_dryCargo_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dryCargo_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Spacecraft/dryCargo$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Spacecraft/dryCargo$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_dryCargo_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_dryCargo_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_dryCargo" 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_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_dryCargo_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_dryCargo" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Decoration_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Decoration_delta_old"(s) SELECT t0.s FROM "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 521
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_abbreviation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_abbreviation_delta_old"(s, o) SELECT t0.s, t0.o FROM "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 522
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_smallestCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_smallestCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "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 523
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_highestState_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_highestState_delta_old"(s, o) SELECT t0.s, t0.o FROM "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 524
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lcc_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lcc_delta_old"(s, o) SELECT t0.s, t0.o FROM "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 525
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winterTemperature_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winterTemperature_delta_old"(s, o) SELECT t0.s, t0.o FROM "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 526
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rating_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rating_delta_old"(s, o) SELECT t0.s, t0.o FROM "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 527
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_status_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_status_delta_old"(s, o) SELECT t0.s, t0.o FROM "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 528
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_piercing_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_piercing_delta_old"(s, o) SELECT t0.s, t0.o FROM "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 529
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_refseq_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_refseq_delta_old"(s, o) SELECT t0.s, t0.o FROM "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 530
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_endowment_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_endowment_delta_old"(s, o) SELECT t0.s, t0.o FROM "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 531
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_kingdom_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_kingdom_delta_old"(s, o) SELECT t0.s, t0.o FROM "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 532
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_parish_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_parish_delta_old"(s, o) SELECT t0.s, t0.o FROM "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 533
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationRuralDensity_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_populationRuralDensity_delta_old"(s, o) SELECT t0.s, t0.o FROM "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 534
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_reopeningDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_reopeningDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "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 535
    ---- 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 536
    ---- 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 537
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_AmericanFootballPlayer_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_AmericanFootballPlayer_delta_old"(s) SELECT t0.s FROM "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 538
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Cycad_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Cycad_delta_old"(s) SELECT t0.s FROM "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 539
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cylinderCount_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cylinderCount_delta_old"(s, o) SELECT t0.s, t0.o FROM "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 540
    ---- 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 541
    ---- 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 542
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_note_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_note_delta_old"(s, o) SELECT t0.s, t0.o FROM "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 543
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/SpaceMission/distanceTraveled$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/SpaceMission/distanceTraveled$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_distanceTraveled_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_distanceTraveled_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_distanceTraveled" 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_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_distanceTraveled_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_distanceTraveled" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 544
    ---- 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 545
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_apoapsis_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_apoapsis_delta_old1"(s, o) SELECT t0.s, t0.o FROM "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 546
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_upperAge_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_upperAge_delta_old"(s, o) SELECT t0.s, t0.o FROM "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 547
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_filmColourType_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_filmColourType_delta_old"(s, o) SELECT t0.s, t0.o FROM "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 548
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_governingBody_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_governingBody_delta_old"(s, o) SELECT t0.s, t0.o FROM "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 549
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Bacteria_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Bacteria_delta_old"(s) SELECT t0.s FROM "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 550
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_AmericanFootballLeague_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_AmericanFootballLeague_delta_old"(s) SELECT t0.s FROM "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 551
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_collection_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_collection_delta_old"(s, o) SELECT t0.s, t0.o FROM "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 552
    ---- 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 553
    ---- 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 554
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_stateOfOrigin_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_stateOfOrigin_delta_old"(s, o) SELECT t0.s, t0.o FROM "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 555
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_crewSize_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_crewSize_delta_old"(s, o) SELECT t0.s, t0.o FROM "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 556
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_employer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_employer_delta_old"(s, o) SELECT t0.s, t0.o FROM "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 557
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_compiler_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_compiler_delta_old"(s, o) SELECT t0.s, t0.o FROM "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 558
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_principal_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_principal_delta_old"(s, o) SELECT t0.s, t0.o FROM "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 559
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/minimumDischarge$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/minimumDischarge$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_minimumDischarge_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_minimumDischarge_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_minimumDischarge" 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_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_minimumDischarge_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_minimumDischarge" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rgbCoordinateGreen_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rgbCoordinateGreen_delta_old"(s, o) SELECT t0.s, t0.o FROM "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 561
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_shoreLength_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_shoreLength_delta_old"(s, o) SELECT t0.s, t0.o FROM "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 562
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ClubMoss_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ClubMoss_delta_old"(s) SELECT t0.s FROM "dbrdf_ClubMoss" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ClubMoss_delta_old" ON "dbrdf_ClubMoss_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ClubMoss_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_ClubMoss"(s) SELECT DISTINCT t0.s FROM "dbrdf_ClubMoss_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_ClubMoss_delta_old";
        INSERT INTO "dbrdf_ClubMoss_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_ClubMoss_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ClubMoss_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Village_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Village_delta_old"(s) SELECT t0.s FROM "dbrdf_Village" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Village_delta_old" ON "dbrdf_Village_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Village_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Village"(s) SELECT DISTINCT t0.s FROM "dbrdf_Village_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Village_delta_old";
        INSERT INTO "dbrdf_Village_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Village_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Village_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Arachnid_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Arachnid_delta_old"(s) SELECT t0.s FROM "dbrdf_Arachnid" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Arachnid_delta_old" ON "dbrdf_Arachnid_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Arachnid_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Arachnid"(s) SELECT DISTINCT t0.s FROM "dbrdf_Arachnid_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Arachnid_delta_old";
        INSERT INTO "dbrdf_Arachnid_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Arachnid_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Arachnid_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Moss_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Moss_delta_old"(s) SELECT t0.s FROM "dbrdf_Moss" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Moss_delta_old" ON "dbrdf_Moss_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Moss_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Moss"(s) SELECT DISTINCT t0.s FROM "dbrdf_Moss_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Moss_delta_old";
        INSERT INTO "dbrdf_Moss_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Moss_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Moss_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Nonrecursive rules

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

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

    -- [Rule] <http://dbpedia.org/ontology/Drug>(?X) :- <http://dbpedia.org/ontology/iupacName>(?X,?X1) .
    INSERT INTO "dbrdf_Drug"(s) SELECT DISTINCT t0.s FROM "dbrdf_iupacName" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Drug" 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_Drug_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Drug_delta_old"(s) SELECT t0.s FROM "dbrdf_Drug" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Drug_delta_old" ON "dbrdf_Drug_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Drug_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Drug"(s) SELECT DISTINCT t0.s FROM "dbrdf_Drug_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Drug_delta_old";
        INSERT INTO "dbrdf_Drug_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Drug_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Drug_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Reptile_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Reptile_delta_old"(s) SELECT t0.s FROM "dbrdf_Reptile" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Reptile_delta_old" ON "dbrdf_Reptile_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Reptile_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Reptile"(s) SELECT DISTINCT t0.s FROM "dbrdf_Reptile_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Reptile_delta_old";
        INSERT INTO "dbrdf_Reptile_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Reptile_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Reptile_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_MusicFestival_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_MusicFestival_delta_old"(s) SELECT t0.s FROM "dbrdf_MusicFestival" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_MusicFestival_delta_old" ON "dbrdf_MusicFestival_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_MusicFestival_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_MusicFestival"(s) SELECT DISTINCT t0.s FROM "dbrdf_MusicFestival_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_MusicFestival_delta_old";
        INSERT INTO "dbrdf_MusicFestival_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_MusicFestival_delta_new" t0;
        TRUNCATE TABLE "dbrdf_MusicFestival_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_BiologicalDatabase_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_BiologicalDatabase_delta_old"(s) SELECT t0.s FROM "dbrdf_BiologicalDatabase" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_BiologicalDatabase_delta_old" ON "dbrdf_BiologicalDatabase_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_BiologicalDatabase_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_BiologicalDatabase"(s) SELECT DISTINCT t0.s FROM "dbrdf_BiologicalDatabase_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_BiologicalDatabase_delta_old";
        INSERT INTO "dbrdf_BiologicalDatabase_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_BiologicalDatabase_delta_new" t0;
        TRUNCATE TABLE "dbrdf_BiologicalDatabase_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Database>(?X) :- <http://dbpedia.org/ontology/BiologicalDatabase>(?X) .
    INSERT INTO "dbrdf_Database"(s) SELECT t0.s FROM "dbrdf_BiologicalDatabase" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Database" 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_Database_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Database_delta_old"(s) SELECT t0.s FROM "dbrdf_Database" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Database_delta_old" ON "dbrdf_Database_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Database_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Database"(s) SELECT DISTINCT t0.s FROM "dbrdf_Database_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Database_delta_old";
        INSERT INTO "dbrdf_Database_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Database_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Database_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 639
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Senator_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Senator_delta_old"(s) SELECT t0.s FROM "dbrdf_Senator" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Senator_delta_old" ON "dbrdf_Senator_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Senator_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Senator"(s) SELECT DISTINCT t0.s FROM "dbrdf_Senator_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Senator_delta_old";
        INSERT INTO "dbrdf_Senator_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Senator_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Senator_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 640
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Criminal_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Criminal_delta_old"(s) SELECT t0.s FROM "dbrdf_Criminal" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Criminal_delta_old" ON "dbrdf_Criminal_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Criminal_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Criminal"(s) SELECT DISTINCT t0.s FROM "dbrdf_Criminal_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Criminal_delta_old";
        INSERT INTO "dbrdf_Criminal_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Criminal_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Criminal_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 641
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_latestPreviewDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_latestPreviewDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_latestPreviewDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_latestPreviewDate_delta_old" ON "dbrdf_latestPreviewDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_latestPreviewDate_delta_old" ON "dbrdf_latestPreviewDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_latestPreviewDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 642
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_parentMountainPeak_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_parentMountainPeak_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_parentMountainPeak" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_parentMountainPeak_delta_old" ON "dbrdf_parentMountainPeak_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_parentMountainPeak_delta_old" ON "dbrdf_parentMountainPeak_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_parentMountainPeak_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 643
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftPatrol_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftPatrol_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_aircraftPatrol" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftPatrol_delta_old" ON "dbrdf_aircraftPatrol_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftPatrol_delta_old" ON "dbrdf_aircraftPatrol_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftPatrol_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 644
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_bicycleInformation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_bicycleInformation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_bicycleInformation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_bicycleInformation_delta_old" ON "dbrdf_bicycleInformation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_bicycleInformation_delta_old" ON "dbrdf_bicycleInformation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_bicycleInformation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 645
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_spurOf_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_spurOf_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_spurOf" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_spurOf_delta_old" ON "dbrdf_spurOf_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_spurOf_delta_old" ON "dbrdf_spurOf_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_spurOf_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 646
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Gnetophytes"(s) SELECT DISTINCT t0.s FROM "dbrdf_Gnetophytes_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Gnetophytes_delta_old";
        INSERT INTO "dbrdf_Gnetophytes_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Gnetophytes_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Gnetophytes_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 647
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 648
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_garrison_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_garrison_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_garrison" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_garrison_delta_old" ON "dbrdf_garrison_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_garrison_delta_old" ON "dbrdf_garrison_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_garrison_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 649
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_draftYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_draftYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_draftYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_draftYear_delta_old" ON "dbrdf_draftYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_draftYear_delta_old" ON "dbrdf_draftYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_draftYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 650
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_certificationDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_certificationDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_certificationDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_certificationDate_delta_old" ON "dbrdf_certificationDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_certificationDate_delta_old" ON "dbrdf_certificationDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_certificationDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 651
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfVehicles_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfVehicles_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfVehicles" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfVehicles_delta_old" ON "dbrdf_numberOfVehicles_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfVehicles_delta_old" ON "dbrdf_numberOfVehicles_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfVehicles_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 652
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_genus_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_genus_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_genus" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_genus_delta_old" ON "dbrdf_genus_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_genus_delta_old" ON "dbrdf_genus_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_genus_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 653
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_architect_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_architect_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_architect" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_architect_delta_old" ON "dbrdf_architect_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_architect_delta_old" ON "dbrdf_architect_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_architect_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 654
    ---- 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 655
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ethnicGroupsInYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ethnicGroupsInYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_ethnicGroupsInYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ethnicGroupsInYear_delta_old" ON "dbrdf_ethnicGroupsInYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ethnicGroupsInYear_delta_old" ON "dbrdf_ethnicGroupsInYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ethnicGroupsInYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 656
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 657
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstLaunch_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstLaunch_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_firstLaunch" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstLaunch_delta_old" ON "dbrdf_firstLaunch_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstLaunch_delta_old" ON "dbrdf_firstLaunch_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstLaunch_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 658
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_majorVolcano_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_majorVolcano_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_majorVolcano" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_majorVolcano_delta_old" ON "dbrdf_majorVolcano_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_majorVolcano_delta_old" ON "dbrdf_majorVolcano_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_majorVolcano_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 659
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sisterNewspaper_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sisterNewspaper_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_sisterNewspaper" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sisterNewspaper_delta_old" ON "dbrdf_sisterNewspaper_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sisterNewspaper_delta_old" ON "dbrdf_sisterNewspaper_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sisterNewspaper_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 660
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_significantDesign_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_significantDesign_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_significantDesign" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_significantDesign_delta_old" ON "dbrdf_significantDesign_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_significantDesign_delta_old" ON "dbrdf_significantDesign_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_significantDesign_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 661
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_wineRegion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_wineRegion_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_wineRegion" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_wineRegion_delta_old" ON "dbrdf_wineRegion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_wineRegion_delta_old" ON "dbrdf_wineRegion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_wineRegion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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