    INSERT INTO "dbrdf_musicalArtist_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_musicalArtist" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_musicalArtist_delta_old" ON "dbrdf_musicalArtist_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_musicalArtist_delta_old" ON "dbrdf_musicalArtist_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_musicalArtist_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_assets_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_assets_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_assets" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_assets_delta_old" ON "dbrdf_assets_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_assets_delta_old" ON "dbrdf_assets_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_assets_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_assets"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_assets_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_assets_delta_old";
        INSERT INTO "dbrdf_assets_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_assets_delta_new" t0;
        TRUNCATE TABLE "dbrdf_assets_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_width_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_width_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_width0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_width_delta_old0" ON "dbrdf_width_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_width_delta_old0" ON "dbrdf_width_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_width_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/Weapon/width$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Weapon/width$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_width_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_width_delta_old0" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_width0" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_width0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_width_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_width_delta_old0";
        INSERT INTO "dbrdf_width_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_width_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_width_delta_new0";

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_cylinderBore0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cylinderBore_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_cylinderBore_delta_old0";
        INSERT INTO "dbrdf_cylinderBore_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cylinderBore_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_cylinderBore_delta_new0";

    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_politicalPartyOfLeader_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_politicalPartyOfLeader_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_politicalPartyOfLeader" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_politicalPartyOfLeader_delta_old" ON "dbrdf_politicalPartyOfLeader_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_politicalPartyOfLeader_delta_old" ON "dbrdf_politicalPartyOfLeader_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_politicalPartyOfLeader_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_politicalPartyOfLeader"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_politicalPartyOfLeader_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_politicalPartyOfLeader_delta_old";
        INSERT INTO "dbrdf_politicalPartyOfLeader_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_politicalPartyOfLeader_delta_new" t0;
        TRUNCATE TABLE "dbrdf_politicalPartyOfLeader_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_Mayor_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Mayor_delta_old"(s) SELECT t0.s FROM "dbrdf_Mayor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Mayor_delta_old" ON "dbrdf_Mayor_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Mayor_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/Mayor$delta_new>(?Y) :- <http://dbpedia.org/ontology/Mayor$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Mayor_delta_new"(s) SELECT t1.o FROM "dbrdf_Mayor_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Mayor" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Mayor"(s) SELECT DISTINCT t0.s FROM "dbrdf_Mayor_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Mayor_delta_old";
        INSERT INTO "dbrdf_Mayor_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Mayor_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Mayor_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_currentStatus_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_currentStatus_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_currentStatus" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_currentStatus_delta_old" ON "dbrdf_currentStatus_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_currentStatus_delta_old" ON "dbrdf_currentStatus_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_currentStatus_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_currentStatus"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_currentStatus_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_currentStatus_delta_old";
        INSERT INTO "dbrdf_currentStatus_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_currentStatus_delta_new" t0;
        TRUNCATE TABLE "dbrdf_currentStatus_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_militaryCommand_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_militaryCommand_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_militaryCommand" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_militaryCommand_delta_old" ON "dbrdf_militaryCommand_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_militaryCommand_delta_old" ON "dbrdf_militaryCommand_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_militaryCommand_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_militaryCommand"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_militaryCommand_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_militaryCommand_delta_old";
        INSERT INTO "dbrdf_militaryCommand_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_militaryCommand_delta_new" t0;
        TRUNCATE TABLE "dbrdf_militaryCommand_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_broadcastRepeater_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_broadcastRepeater_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_broadcastRepeater" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_broadcastRepeater_delta_old" ON "dbrdf_broadcastRepeater_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_broadcastRepeater_delta_old" ON "dbrdf_broadcastRepeater_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_broadcastRepeater_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_broadcastRepeater"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_broadcastRepeater_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_broadcastRepeater_delta_old";
        INSERT INTO "dbrdf_broadcastRepeater_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_broadcastRepeater_delta_new" t0;
        TRUNCATE TABLE "dbrdf_broadcastRepeater_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_Muscle_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Muscle_delta_old"(s) SELECT t0.s FROM "dbrdf_Muscle" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Muscle_delta_old" ON "dbrdf_Muscle_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Muscle_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/Muscle$delta_new>(?Y) :- <http://dbpedia.org/ontology/Muscle$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Muscle_delta_new"(s) SELECT t1.o FROM "dbrdf_Muscle_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Muscle" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Muscle"(s) SELECT DISTINCT t0.s FROM "dbrdf_Muscle_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Muscle_delta_old";
        INSERT INTO "dbrdf_Muscle_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Muscle_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Muscle_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_runtime_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_runtime_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_runtime" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_runtime_delta_old" ON "dbrdf_runtime_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_runtime_delta_old" ON "dbrdf_runtime_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_runtime_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_runtime"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_runtime_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_runtime_delta_old";
        INSERT INTO "dbrdf_runtime_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_runtime_delta_new" t0;
        TRUNCATE TABLE "dbrdf_runtime_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_olympicOathSwornByJudge_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_olympicOathSwornByJudge_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_olympicOathSwornByJudge" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_olympicOathSwornByJudge_delta_old" ON "dbrdf_olympicOathSwornByJudge_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_olympicOathSwornByJudge_delta_old" ON "dbrdf_olympicOathSwornByJudge_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_olympicOathSwornByJudge_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_olympicOathSwornByJudge"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_olympicOathSwornByJudge_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_olympicOathSwornByJudge_delta_old";
        INSERT INTO "dbrdf_olympicOathSwornByJudge_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_olympicOathSwornByJudge_delta_new" t0;
        TRUNCATE TABLE "dbrdf_olympicOathSwornByJudge_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_personFunction_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_personFunction_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_personFunction" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_personFunction_delta_old" ON "dbrdf_personFunction_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_personFunction_delta_old" ON "dbrdf_personFunction_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_personFunction_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_personFunction"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_personFunction_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_personFunction_delta_old";
        INSERT INTO "dbrdf_personFunction_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_personFunction_delta_new" t0;
        TRUNCATE TABLE "dbrdf_personFunction_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_podiums_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_podiums_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_podiums" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_podiums_delta_old" ON "dbrdf_podiums_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_podiums_delta_old" ON "dbrdf_podiums_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_podiums_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_podiums"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_podiums_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_podiums_delta_old";
        INSERT INTO "dbrdf_podiums_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_podiums_delta_new" t0;
        TRUNCATE TABLE "dbrdf_podiums_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_languageRegulator_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_languageRegulator_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_languageRegulator" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_languageRegulator_delta_old" ON "dbrdf_languageRegulator_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_languageRegulator_delta_old" ON "dbrdf_languageRegulator_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_languageRegulator_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_languageRegulator"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_languageRegulator_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_languageRegulator_delta_old";
        INSERT INTO "dbrdf_languageRegulator_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_languageRegulator_delta_new" t0;
        TRUNCATE TABLE "dbrdf_languageRegulator_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_areaTotal_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_areaTotal_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_areaTotal" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_areaTotal_delta_old" ON "dbrdf_areaTotal_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_areaTotal_delta_old" ON "dbrdf_areaTotal_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaTotal_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_areaTotal"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_areaTotal_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_areaTotal_delta_old";
        INSERT INTO "dbrdf_areaTotal_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_areaTotal_delta_new" t0;
        TRUNCATE TABLE "dbrdf_areaTotal_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_stylisticOrigin_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_stylisticOrigin_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_stylisticOrigin" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_stylisticOrigin_delta_old" ON "dbrdf_stylisticOrigin_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_stylisticOrigin_delta_old" ON "dbrdf_stylisticOrigin_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_stylisticOrigin_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_stylisticOrigin"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_stylisticOrigin_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_stylisticOrigin_delta_old";
        INSERT INTO "dbrdf_stylisticOrigin_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_stylisticOrigin_delta_new" t0;
        TRUNCATE TABLE "dbrdf_stylisticOrigin_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_RadioControlledRacingLeague_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_RadioControlledRacingLeague_delta_old"(s) SELECT t0.s FROM "dbrdf_RadioControlledRacingLeague" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_RadioControlledRacingLeague_delta_old" ON "dbrdf_RadioControlledRacingLeague_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_RadioControlledRacingLeague_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/RadioControlledRacingLeague$delta_new>(?Y) :- <http://dbpedia.org/ontology/RadioControlledRacingLeague$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_RadioControlledRacingLeague_delta_new"(s) SELECT t1.o FROM "dbrdf_RadioControlledRacingLeague_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_RadioControlledRacingLeague" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_RadioControlledRacingLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_RadioControlledRacingLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_RadioControlledRacingLeague_delta_old";
        INSERT INTO "dbrdf_RadioControlledRacingLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_RadioControlledRacingLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_RadioControlledRacingLeague_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_musicComposer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_musicComposer_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_musicComposer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_musicComposer_delta_old" ON "dbrdf_musicComposer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_musicComposer_delta_old" ON "dbrdf_musicComposer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_musicComposer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_musicComposer"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_musicComposer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_musicComposer_delta_old";
        INSERT INTO "dbrdf_musicComposer_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_musicComposer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_musicComposer_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_numberOfFederalDeputies_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfFederalDeputies_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfFederalDeputies" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfFederalDeputies_delta_old" ON "dbrdf_numberOfFederalDeputies_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfFederalDeputies_delta_old" ON "dbrdf_numberOfFederalDeputies_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfFederalDeputies_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_numberOfFederalDeputies"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfFederalDeputies_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_numberOfFederalDeputies_delta_old";
        INSERT INTO "dbrdf_numberOfFederalDeputies_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfFederalDeputies_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfFederalDeputies_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_mass_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mass_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_mass0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mass_delta_old0" ON "dbrdf_mass_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_mass_delta_old0" ON "dbrdf_mass_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mass_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_mass0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_mass_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_mass_delta_old0";
        INSERT INTO "dbrdf_mass_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_mass_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_mass_delta_new0";

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_port2DockedTime0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_port2DockedTime_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_port2DockedTime_delta_old0";
        INSERT INTO "dbrdf_port2DockedTime_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_port2DockedTime_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_port2DockedTime_delta_new0";

    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_modelStartDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_modelStartDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_modelStartDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_modelStartDate_delta_old" ON "dbrdf_modelStartDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_modelStartDate_delta_old" ON "dbrdf_modelStartDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_modelStartDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_modelStartDate"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_modelStartDate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_modelStartDate_delta_old";
        INSERT INTO "dbrdf_modelStartDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_modelStartDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_modelStartDate_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_BasketballPlayer_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_BasketballPlayer_delta_old"(s) SELECT t0.s FROM "dbrdf_BasketballPlayer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_BasketballPlayer_delta_old" ON "dbrdf_BasketballPlayer_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_BasketballPlayer_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/BasketballPlayer$delta_new>(?Y) :- <http://dbpedia.org/ontology/BasketballPlayer$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_BasketballPlayer_delta_new"(s) SELECT t1.o FROM "dbrdf_BasketballPlayer_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_BasketballPlayer" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_BasketballPlayer"(s) SELECT DISTINCT t0.s FROM "dbrdf_BasketballPlayer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_BasketballPlayer_delta_old";
        INSERT INTO "dbrdf_BasketballPlayer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_BasketballPlayer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_BasketballPlayer_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_cmykCoordinateCyanic_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cmykCoordinateCyanic_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_cmykCoordinateCyanic" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cmykCoordinateCyanic_delta_old" ON "dbrdf_cmykCoordinateCyanic_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_cmykCoordinateCyanic_delta_old" ON "dbrdf_cmykCoordinateCyanic_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cmykCoordinateCyanic_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_cmykCoordinateCyanic"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cmykCoordinateCyanic_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_cmykCoordinateCyanic_delta_old";
        INSERT INTO "dbrdf_cmykCoordinateCyanic_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cmykCoordinateCyanic_delta_new" t0;
        TRUNCATE TABLE "dbrdf_cmykCoordinateCyanic_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_soccerTournamentMostSteady_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_soccerTournamentMostSteady_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_soccerTournamentMostSteady" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_soccerTournamentMostSteady_delta_old" ON "dbrdf_soccerTournamentMostSteady_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_soccerTournamentMostSteady_delta_old" ON "dbrdf_soccerTournamentMostSteady_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_soccerTournamentMostSteady_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_soccerTournamentMostSteady"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_soccerTournamentMostSteady_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_soccerTournamentMostSteady_delta_old";
        INSERT INTO "dbrdf_soccerTournamentMostSteady_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_soccerTournamentMostSteady_delta_new" t0;
        TRUNCATE TABLE "dbrdf_soccerTournamentMostSteady_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_schoolNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_schoolNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_schoolNumber" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_schoolNumber_delta_old" ON "dbrdf_schoolNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_schoolNumber_delta_old" ON "dbrdf_schoolNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_schoolNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_schoolNumber"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_schoolNumber_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_schoolNumber_delta_old";
        INSERT INTO "dbrdf_schoolNumber_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_schoolNumber_delta_new" t0;
        TRUNCATE TABLE "dbrdf_schoolNumber_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_title_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_title_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_title" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_title_delta_old" ON "dbrdf_title_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_title_delta_old" ON "dbrdf_title_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_title_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    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_decideDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_decideDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_decideDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_decideDate_delta_old" ON "dbrdf_decideDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_decideDate_delta_old" ON "dbrdf_decideDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_decideDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 514
    ---- DEPENDS ON: 513, 110, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- [Rule] <http://dbpedia.org/ontology/SupremeCourtOfTheUnitedStatesCase>(?X) :- <http://dbpedia.org/ontology/argueDate>(?X,?X1) .
    INSERT INTO "dbrdf_SupremeCourtOfTheUnitedStatesCase"(s) SELECT DISTINCT t0.s FROM "dbrdf_argueDate" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_SupremeCourtOfTheUnitedStatesCase" 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_SupremeCourtOfTheUnitedStatesCase_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SupremeCourtOfTheUnitedStatesCase_delta_old"(s) SELECT t0.s FROM "dbrdf_SupremeCourtOfTheUnitedStatesCase" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SupremeCourtOfTheUnitedStatesCase_delta_old" ON "dbrdf_SupremeCourtOfTheUnitedStatesCase_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SupremeCourtOfTheUnitedStatesCase_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/SupremeCourtOfTheUnitedStatesCase$delta_new>(?Y) :- <http://dbpedia.org/ontology/SupremeCourtOfTheUnitedStatesCase$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_SupremeCourtOfTheUnitedStatesCase_delta_new"(s) SELECT t1.o FROM "dbrdf_SupremeCourtOfTheUnitedStatesCase_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_SupremeCourtOfTheUnitedStatesCase" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_SupremeCourtOfTheUnitedStatesCase"(s) SELECT DISTINCT t0.s FROM "dbrdf_SupremeCourtOfTheUnitedStatesCase_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SupremeCourtOfTheUnitedStatesCase_delta_old";
        INSERT INTO "dbrdf_SupremeCourtOfTheUnitedStatesCase_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SupremeCourtOfTheUnitedStatesCase_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SupremeCourtOfTheUnitedStatesCase_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 515
    ---- DEPENDS ON: 514, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/LegalCase>(?X) :- <http://dbpedia.org/ontology/SupremeCourtOfTheUnitedStatesCase>(?X) .
    INSERT INTO "dbrdf_LegalCase"(s) SELECT t0.s FROM "dbrdf_SupremeCourtOfTheUnitedStatesCase" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_LegalCase" 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_LegalCase_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_LegalCase_delta_old"(s) SELECT t0.s FROM "dbrdf_LegalCase" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_LegalCase_delta_old" ON "dbrdf_LegalCase_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_LegalCase_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/LegalCase$delta_new>(?Y) :- <http://dbpedia.org/ontology/LegalCase$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_LegalCase_delta_new"(s) SELECT t1.o FROM "dbrdf_LegalCase_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_LegalCase" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_LegalCase"(s) SELECT DISTINCT t0.s FROM "dbrdf_LegalCase_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_LegalCase_delta_old";
        INSERT INTO "dbrdf_LegalCase_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_LegalCase_delta_new" t0;
        TRUNCATE TABLE "dbrdf_LegalCase_delta_new";

    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_creationYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_creationYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_creationYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_creationYear_delta_old" ON "dbrdf_creationYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_creationYear_delta_old" ON "dbrdf_creationYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_creationYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_creationYear"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_creationYear_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_creationYear_delta_old";
        INSERT INTO "dbrdf_creationYear_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_creationYear_delta_new" t0;
        TRUNCATE TABLE "dbrdf_creationYear_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_ascent_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ascent_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_ascent" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ascent_delta_old" ON "dbrdf_ascent_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ascent_delta_old" ON "dbrdf_ascent_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ascent_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_ascent"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_ascent_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_ascent_delta_old";
        INSERT INTO "dbrdf_ascent_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_ascent_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ascent_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_spacewalkBegin_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_spacewalkBegin_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_spacewalkBegin" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_spacewalkBegin_delta_old" ON "dbrdf_spacewalkBegin_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_spacewalkBegin_delta_old" ON "dbrdf_spacewalkBegin_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_spacewalkBegin_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_spacewalkBegin"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_spacewalkBegin_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_spacewalkBegin_delta_old";
        INSERT INTO "dbrdf_spacewalkBegin_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_spacewalkBegin_delta_new" t0;
        TRUNCATE TABLE "dbrdf_spacewalkBegin_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_nextMission_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nextMission_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_nextMission" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nextMission_delta_old" ON "dbrdf_nextMission_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nextMission_delta_old" ON "dbrdf_nextMission_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nextMission_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_nextMission"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_nextMission_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_nextMission_delta_old";
        INSERT INTO "dbrdf_nextMission_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_nextMission_delta_new" t0;
        TRUNCATE TABLE "dbrdf_nextMission_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_officerInCharge_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_officerInCharge_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_officerInCharge" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_officerInCharge_delta_old" ON "dbrdf_officerInCharge_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_officerInCharge_delta_old" ON "dbrdf_officerInCharge_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_officerInCharge_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_officerInCharge"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_officerInCharge_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_officerInCharge_delta_old";
        INSERT INTO "dbrdf_officerInCharge_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_officerInCharge_delta_new" t0;
        TRUNCATE TABLE "dbrdf_officerInCharge_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_head_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_head_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_head" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_head_delta_old" ON "dbrdf_head_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_head_delta_old" ON "dbrdf_head_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_head_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_head"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_head_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_head_delta_old";
        INSERT INTO "dbrdf_head_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_head_delta_new" t0;
        TRUNCATE TABLE "dbrdf_head_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_MouseGene_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_MouseGene_delta_old"(s) SELECT t0.s FROM "dbrdf_MouseGene" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_MouseGene_delta_old" ON "dbrdf_MouseGene_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_MouseGene_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/MouseGene$delta_new>(?Y) :- <http://dbpedia.org/ontology/MouseGene$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_MouseGene_delta_new"(s) SELECT t1.o FROM "dbrdf_MouseGene_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_MouseGene" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_MouseGene"(s) SELECT DISTINCT t0.s FROM "dbrdf_MouseGene_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_MouseGene_delta_old";
        INSERT INTO "dbrdf_MouseGene_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_MouseGene_delta_new" t0;
        TRUNCATE TABLE "dbrdf_MouseGene_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_youthWing_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_youthWing_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_youthWing" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_youthWing_delta_old" ON "dbrdf_youthWing_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_youthWing_delta_old" ON "dbrdf_youthWing_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_youthWing_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_youthWing"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_youthWing_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_youthWing_delta_old";
        INSERT INTO "dbrdf_youthWing_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_youthWing_delta_new" t0;
        TRUNCATE TABLE "dbrdf_youthWing_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_coExecutiveProducer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_coExecutiveProducer_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_coExecutiveProducer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_coExecutiveProducer_delta_old" ON "dbrdf_coExecutiveProducer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_coExecutiveProducer_delta_old" ON "dbrdf_coExecutiveProducer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_coExecutiveProducer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_coExecutiveProducer"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_coExecutiveProducer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_coExecutiveProducer_delta_old";
        INSERT INTO "dbrdf_coExecutiveProducer_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_coExecutiveProducer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_coExecutiveProducer_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_winsAtLAGT_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtLAGT_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_winsAtLAGT" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtLAGT_delta_old" ON "dbrdf_winsAtLAGT_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtLAGT_delta_old" ON "dbrdf_winsAtLAGT_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtLAGT_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_winsAtLAGT"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_winsAtLAGT_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_winsAtLAGT_delta_old";
        INSERT INTO "dbrdf_winsAtLAGT_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_winsAtLAGT_delta_new" t0;
        TRUNCATE TABLE "dbrdf_winsAtLAGT_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_maximumBoatLength_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_maximumBoatLength_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_maximumBoatLength" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_maximumBoatLength_delta_old" ON "dbrdf_maximumBoatLength_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_maximumBoatLength_delta_old" ON "dbrdf_maximumBoatLength_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumBoatLength_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_maximumBoatLength"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_maximumBoatLength_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_maximumBoatLength_delta_old";
        INSERT INTO "dbrdf_maximumBoatLength_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_maximumBoatLength_delta_new" t0;
        TRUNCATE TABLE "dbrdf_maximumBoatLength_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_winsAtLET_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtLET_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_winsAtLET" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtLET_delta_old" ON "dbrdf_winsAtLET_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtLET_delta_old" ON "dbrdf_winsAtLET_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtLET_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_winsAtLET"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_winsAtLET_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_winsAtLET_delta_old";
        INSERT INTO "dbrdf_winsAtLET_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_winsAtLET_delta_new" t0;
        TRUNCATE TABLE "dbrdf_winsAtLET_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_pistonStroke_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_pistonStroke_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_pistonStroke0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_pistonStroke_delta_old0" ON "dbrdf_pistonStroke_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_pistonStroke_delta_old0" ON "dbrdf_pistonStroke_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_pistonStroke_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_pistonStroke0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_pistonStroke_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_pistonStroke_delta_old0";
        INSERT INTO "dbrdf_pistonStroke_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_pistonStroke_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_pistonStroke_delta_new0";

    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_senator_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_senator_delta_old"(s, o) SELECT t0.s, t0.o 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, o); CREATE INDEX "IDX_1_dbrdf_senator_delta_old" ON "dbrdf_senator_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_senator_delta_new"(s integer, o 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,?X1) :- <http://dbpedia.org/ontology/senator$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_senator_delta_new"(s, o) SELECT t1.o, t0.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 AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_senator"(s, o) SELECT DISTINCT t0.s, t0.o 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, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_senator_delta_new" t0;
        TRUNCATE TABLE "dbrdf_senator_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_aircraftHelicopterCargo_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftHelicopterCargo_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_aircraftHelicopterCargo" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftHelicopterCargo_delta_old" ON "dbrdf_aircraftHelicopterCargo_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftHelicopterCargo_delta_old" ON "dbrdf_aircraftHelicopterCargo_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftHelicopterCargo_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_aircraftHelicopterCargo"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_aircraftHelicopterCargo_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_aircraftHelicopterCargo_delta_old";
        INSERT INTO "dbrdf_aircraftHelicopterCargo_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_aircraftHelicopterCargo_delta_new" t0;
        TRUNCATE TABLE "dbrdf_aircraftHelicopterCargo_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_broadcastStationClass_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_broadcastStationClass_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_broadcastStationClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_broadcastStationClass_delta_old" ON "dbrdf_broadcastStationClass_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_broadcastStationClass_delta_old" ON "dbrdf_broadcastStationClass_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_broadcastStationClass_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_broadcastStationClass"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_broadcastStationClass_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_broadcastStationClass_delta_old";
        INSERT INTO "dbrdf_broadcastStationClass_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_broadcastStationClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_broadcastStationClass_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_numberOfBronzeMedalsWon_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfBronzeMedalsWon_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfBronzeMedalsWon" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfBronzeMedalsWon_delta_old" ON "dbrdf_numberOfBronzeMedalsWon_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfBronzeMedalsWon_delta_old" ON "dbrdf_numberOfBronzeMedalsWon_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfBronzeMedalsWon_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_numberOfBronzeMedalsWon"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfBronzeMedalsWon_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_numberOfBronzeMedalsWon_delta_old";
        INSERT INTO "dbrdf_numberOfBronzeMedalsWon_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfBronzeMedalsWon_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfBronzeMedalsWon_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_shipBeam_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_shipBeam_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_shipBeam" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_shipBeam_delta_old" ON "dbrdf_shipBeam_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_shipBeam_delta_old" ON "dbrdf_shipBeam_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_shipBeam_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_shipBeam"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_shipBeam_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_shipBeam_delta_old";
        INSERT INTO "dbrdf_shipBeam_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_shipBeam_delta_new" t0;
        TRUNCATE TABLE "dbrdf_shipBeam_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_draft_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_draft_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_draft" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_draft_delta_old" ON "dbrdf_draft_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_draft_delta_old" ON "dbrdf_draft_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_draft_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_draft"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_draft_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_draft_delta_old";
        INSERT INTO "dbrdf_draft_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_draft_delta_new" t0;
        TRUNCATE TABLE "dbrdf_draft_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_licensee_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_licensee_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_licensee" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_licensee_delta_old" ON "dbrdf_licensee_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_licensee_delta_old" ON "dbrdf_licensee_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_licensee_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_licensee"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_licensee_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_licensee_delta_old";
        INSERT INTO "dbrdf_licensee_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_licensee_delta_new" t0;
        TRUNCATE TABLE "dbrdf_licensee_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_ChristianPatriarch_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ChristianPatriarch_delta_old"(s) SELECT t0.s FROM "dbrdf_ChristianPatriarch" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ChristianPatriarch_delta_old" ON "dbrdf_ChristianPatriarch_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ChristianPatriarch_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/ChristianPatriarch$delta_new>(?Y) :- <http://dbpedia.org/ontology/ChristianPatriarch$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_ChristianPatriarch_delta_new"(s) SELECT t1.o FROM "dbrdf_ChristianPatriarch_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_ChristianPatriarch" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_ChristianPatriarch"(s) SELECT DISTINCT t0.s FROM "dbrdf_ChristianPatriarch_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_ChristianPatriarch_delta_old";
        INSERT INTO "dbrdf_ChristianPatriarch_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_ChristianPatriarch_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ChristianPatriarch_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_summerTemperature_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_summerTemperature_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_summerTemperature" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_summerTemperature_delta_old" ON "dbrdf_summerTemperature_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_summerTemperature_delta_old" ON "dbrdf_summerTemperature_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_summerTemperature_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_summerTemperature"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_summerTemperature_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_summerTemperature_delta_old";
        INSERT INTO "dbrdf_summerTemperature_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_summerTemperature_delta_new" t0;
        TRUNCATE TABLE "dbrdf_summerTemperature_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_shipDisplacement_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_shipDisplacement_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_shipDisplacement" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_shipDisplacement_delta_old" ON "dbrdf_shipDisplacement_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_shipDisplacement_delta_old" ON "dbrdf_shipDisplacement_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_shipDisplacement_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_shipDisplacement"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_shipDisplacement_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_shipDisplacement_delta_old";
        INSERT INTO "dbrdf_shipDisplacement_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_shipDisplacement_delta_new" t0;
        TRUNCATE TABLE "dbrdf_shipDisplacement_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_councilArea_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_councilArea_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_councilArea" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_councilArea_delta_old" ON "dbrdf_councilArea_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_councilArea_delta_old" ON "dbrdf_councilArea_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_councilArea_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_councilArea"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_councilArea_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_councilArea_delta_old";
        INSERT INTO "dbrdf_councilArea_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_councilArea_delta_new" t0;
        TRUNCATE TABLE "dbrdf_councilArea_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_projectStartDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_projectStartDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_projectStartDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_projectStartDate_delta_old" ON "dbrdf_projectStartDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_projectStartDate_delta_old" ON "dbrdf_projectStartDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectStartDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_projectStartDate"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_projectStartDate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_projectStartDate_delta_old";
        INSERT INTO "dbrdf_projectStartDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_projectStartDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_projectStartDate_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_firstGame_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstGame_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_firstGame" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstGame_delta_old" ON "dbrdf_firstGame_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstGame_delta_old" ON "dbrdf_firstGame_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstGame_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_firstGame"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_firstGame_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_firstGame_delta_old";
        INSERT INTO "dbrdf_firstGame_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_firstGame_delta_new" t0;
        TRUNCATE TABLE "dbrdf_firstGame_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_loadLimit_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_loadLimit_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_loadLimit" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_loadLimit_delta_old" ON "dbrdf_loadLimit_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_loadLimit_delta_old" ON "dbrdf_loadLimit_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_loadLimit_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_loadLimit"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_loadLimit_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_loadLimit_delta_old";
        INSERT INTO "dbrdf_loadLimit_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_loadLimit_delta_new" t0;
        TRUNCATE TABLE "dbrdf_loadLimit_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_yearOfElectrification_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_yearOfElectrification_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_yearOfElectrification" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_yearOfElectrification_delta_old" ON "dbrdf_yearOfElectrification_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_yearOfElectrification_delta_old" ON "dbrdf_yearOfElectrification_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_yearOfElectrification_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_yearOfElectrification"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_yearOfElectrification_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_yearOfElectrification_delta_old";
        INSERT INTO "dbrdf_yearOfElectrification_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_yearOfElectrification_delta_new" t0;
        TRUNCATE TABLE "dbrdf_yearOfElectrification_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_cuisine_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cuisine_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_cuisine" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cuisine_delta_old" ON "dbrdf_cuisine_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_cuisine_delta_old" ON "dbrdf_cuisine_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cuisine_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_cuisine"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cuisine_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_cuisine_delta_old";
        INSERT INTO "dbrdf_cuisine_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cuisine_delta_new" t0;
        TRUNCATE TABLE "dbrdf_cuisine_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_supplies_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_supplies_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_supplies" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_supplies_delta_old" ON "dbrdf_supplies_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_supplies_delta_old" ON "dbrdf_supplies_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_supplies_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_PowerStation"(s) SELECT DISTINCT t0.s FROM "dbrdf_PowerStation_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_PowerStation_delta_old";
        INSERT INTO "dbrdf_PowerStation_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_PowerStation_delta_new" t0;
        TRUNCATE TABLE "dbrdf_PowerStation_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_transmission_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_transmission_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_transmission" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_transmission_delta_old" ON "dbrdf_transmission_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_transmission_delta_old" ON "dbrdf_transmission_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_transmission_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_transmission"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_transmission_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_transmission_delta_old";
        INSERT INTO "dbrdf_transmission_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_transmission_delta_new" t0;
        TRUNCATE TABLE "dbrdf_transmission_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_inchi_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_inchi_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_inchi" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_inchi_delta_old" ON "dbrdf_inchi_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_inchi_delta_old" ON "dbrdf_inchi_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_inchi_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_inchi"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_inchi_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_inchi_delta_old";
        INSERT INTO "dbrdf_inchi_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_inchi_delta_new" t0;
        TRUNCATE TABLE "dbrdf_inchi_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_bSide_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_bSide_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_bSide" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_bSide_delta_old" ON "dbrdf_bSide_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_bSide_delta_old" ON "dbrdf_bSide_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_bSide_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_bSide"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_bSide_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_bSide_delta_old";
        INSERT INTO "dbrdf_bSide_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_bSide_delta_new" t0;
        TRUNCATE TABLE "dbrdf_bSide_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_headAlloy_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_headAlloy_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_headAlloy" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_headAlloy_delta_old" ON "dbrdf_headAlloy_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_headAlloy_delta_old" ON "dbrdf_headAlloy_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_headAlloy_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_headAlloy"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_headAlloy_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_headAlloy_delta_old";
        INSERT INTO "dbrdf_headAlloy_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_headAlloy_delta_new" t0;
        TRUNCATE TABLE "dbrdf_headAlloy_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_numberOfMinistries_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfMinistries_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfMinistries" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfMinistries_delta_old" ON "dbrdf_numberOfMinistries_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfMinistries_delta_old" ON "dbrdf_numberOfMinistries_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfMinistries_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_numberOfMinistries"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfMinistries_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_numberOfMinistries_delta_old";
        INSERT INTO "dbrdf_numberOfMinistries_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfMinistries_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfMinistries_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_dorlandsPrefix_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dorlandsPrefix_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_dorlandsPrefix" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dorlandsPrefix_delta_old" ON "dbrdf_dorlandsPrefix_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dorlandsPrefix_delta_old" ON "dbrdf_dorlandsPrefix_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dorlandsPrefix_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_dorlandsPrefix"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_dorlandsPrefix_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_dorlandsPrefix_delta_old";
        INSERT INTO "dbrdf_dorlandsPrefix_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_dorlandsPrefix_delta_new" t0;
        TRUNCATE TABLE "dbrdf_dorlandsPrefix_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_giniCoefficientRanking_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_giniCoefficientRanking_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_giniCoefficientRanking" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_giniCoefficientRanking_delta_old" ON "dbrdf_giniCoefficientRanking_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_giniCoefficientRanking_delta_old" ON "dbrdf_giniCoefficientRanking_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_giniCoefficientRanking_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_giniCoefficientRanking"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_giniCoefficientRanking_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_giniCoefficientRanking_delta_old";
        INSERT INTO "dbrdf_giniCoefficientRanking_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_giniCoefficientRanking_delta_new" t0;
        TRUNCATE TABLE "dbrdf_giniCoefficientRanking_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_coronationDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_coronationDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_coronationDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_coronationDate_delta_old" ON "dbrdf_coronationDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_coronationDate_delta_old" ON "dbrdf_coronationDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_coronationDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_coronationDate"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_coronationDate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_coronationDate_delta_old";
        INSERT INTO "dbrdf_coronationDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_coronationDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_coronationDate_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_passengersPerYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_passengersPerYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_passengersPerYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_passengersPerYear_delta_old" ON "dbrdf_passengersPerYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_passengersPerYear_delta_old" ON "dbrdf_passengersPerYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_passengersPerYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_passengersPerYear"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_passengersPerYear_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_passengersPerYear_delta_old";
        INSERT INTO "dbrdf_passengersPerYear_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_passengersPerYear_delta_new" t0;
        TRUNCATE TABLE "dbrdf_passengersPerYear_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_lounge_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lounge_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lounge" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lounge_delta_old" ON "dbrdf_lounge_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lounge_delta_old" ON "dbrdf_lounge_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lounge_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_lounge"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lounge_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_lounge_delta_old";
        INSERT INTO "dbrdf_lounge_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lounge_delta_new" t0;
        TRUNCATE TABLE "dbrdf_lounge_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_shoeNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_shoeNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_shoeNumber" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_shoeNumber_delta_old" ON "dbrdf_shoeNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_shoeNumber_delta_old" ON "dbrdf_shoeNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_shoeNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_shoeNumber"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_shoeNumber_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_shoeNumber_delta_old";
        INSERT INTO "dbrdf_shoeNumber_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_shoeNumber_delta_new" t0;
        TRUNCATE TABLE "dbrdf_shoeNumber_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_numberOfRooms_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfRooms_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfRooms" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfRooms_delta_old" ON "dbrdf_numberOfRooms_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfRooms_delta_old" ON "dbrdf_numberOfRooms_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfRooms_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_numberOfRooms"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfRooms_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_numberOfRooms_delta_old";
        INSERT INTO "dbrdf_numberOfRooms_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfRooms_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfRooms_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_wikiPageID_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_wikiPageID_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_wikiPageID" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_wikiPageID_delta_old" ON "dbrdf_wikiPageID_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_wikiPageID_delta_old" ON "dbrdf_wikiPageID_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_wikiPageID_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_wikiPageID"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_wikiPageID_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_wikiPageID_delta_old";
        INSERT INTO "dbrdf_wikiPageID_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_wikiPageID_delta_new" t0;
        TRUNCATE TABLE "dbrdf_wikiPageID_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_atcPrefix_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_atcPrefix_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_atcPrefix" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_atcPrefix_delta_old" ON "dbrdf_atcPrefix_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_atcPrefix_delta_old" ON "dbrdf_atcPrefix_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_atcPrefix_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_atcPrefix"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_atcPrefix_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_atcPrefix_delta_old";
        INSERT INTO "dbrdf_atcPrefix_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_atcPrefix_delta_new" t0;
        TRUNCATE TABLE "dbrdf_atcPrefix_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_numberOfTracks_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfTracks_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfTracks" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfTracks_delta_old" ON "dbrdf_numberOfTracks_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfTracks_delta_old" ON "dbrdf_numberOfTracks_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfTracks_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_numberOfTracks"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfTracks_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_numberOfTracks_delta_old";
        INSERT INTO "dbrdf_numberOfTracks_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfTracks_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfTracks_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_projectReferenceID_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_projectReferenceID_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_projectReferenceID" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_projectReferenceID_delta_old" ON "dbrdf_projectReferenceID_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_projectReferenceID_delta_old" ON "dbrdf_projectReferenceID_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectReferenceID_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_projectReferenceID"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_projectReferenceID_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_projectReferenceID_delta_old";
        INSERT INTO "dbrdf_projectReferenceID_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_projectReferenceID_delta_new" t0;
        TRUNCATE TABLE "dbrdf_projectReferenceID_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_patent_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_patent_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_patent" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_patent_delta_old" ON "dbrdf_patent_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_patent_delta_old" ON "dbrdf_patent_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_patent_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_patent"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_patent_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_patent_delta_old";
        INSERT INTO "dbrdf_patent_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_patent_delta_new" t0;
        TRUNCATE TABLE "dbrdf_patent_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_GovernmentOrganization_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_GovernmentOrganization_delta_old"(s) SELECT t0.s FROM "dbrdf_GovernmentOrganization" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_GovernmentOrganization_delta_old" ON "dbrdf_GovernmentOrganization_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_GovernmentOrganization_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_GovernmentAgency_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_GovernmentAgency_delta_old"(s) SELECT t0.s FROM "dbrdf_GovernmentAgency" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_GovernmentAgency_delta_old" ON "dbrdf_GovernmentAgency_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_GovernmentAgency_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://schema.org/GovernmentOrganization$delta_new>(?X) :- <http://dbpedia.org/ontology/GovernmentAgency$delta_old>(?X) .
        INSERT INTO "dbrdf_GovernmentOrganization_delta_new"(s) SELECT t0.s FROM "dbrdf_GovernmentAgency_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_GovernmentOrganization" ex WHERE ex.s = t0.s);


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


        -- <http://dbpedia.org/ontology/GovernmentAgency$delta_new>(?X) :- <http://schema.org/GovernmentOrganization$delta_old>(?X) .
        INSERT INTO "dbrdf_GovernmentAgency_delta_new"(s) SELECT t0.s FROM "dbrdf_GovernmentOrganization_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_GovernmentAgency" ex WHERE ex.s = t0.s);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_GovernmentOrganization"(s) SELECT DISTINCT t0.s FROM "dbrdf_GovernmentOrganization_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_GovernmentOrganization_delta_old";
        INSERT INTO "dbrdf_GovernmentOrganization_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_GovernmentOrganization_delta_new" t0;
        TRUNCATE TABLE "dbrdf_GovernmentOrganization_delta_new";

        INSERT INTO "dbrdf_GovernmentAgency"(s) SELECT DISTINCT t0.s FROM "dbrdf_GovernmentAgency_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_GovernmentAgency_delta_old";
        INSERT INTO "dbrdf_GovernmentAgency_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_GovernmentAgency_delta_new" t0;
        TRUNCATE TABLE "dbrdf_GovernmentAgency_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_publicationDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_publicationDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_publicationDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_publicationDate_delta_old" ON "dbrdf_publicationDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_publicationDate_delta_old" ON "dbrdf_publicationDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_publicationDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_publicationDate"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_publicationDate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_publicationDate_delta_old";
        INSERT INTO "dbrdf_publicationDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_publicationDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_publicationDate_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_bronzeMedalist_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_bronzeMedalist_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_bronzeMedalist" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_bronzeMedalist_delta_old" ON "dbrdf_bronzeMedalist_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_bronzeMedalist_delta_old" ON "dbrdf_bronzeMedalist_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_bronzeMedalist_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_bronzeMedalist"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_bronzeMedalist_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_bronzeMedalist_delta_old";
        INSERT INTO "dbrdf_bronzeMedalist_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_bronzeMedalist_delta_new" t0;
        TRUNCATE TABLE "dbrdf_bronzeMedalist_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_annualTemperature_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_annualTemperature_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_annualTemperature" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_annualTemperature_delta_old" ON "dbrdf_annualTemperature_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_annualTemperature_delta_old" ON "dbrdf_annualTemperature_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_annualTemperature_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_annualTemperature"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_annualTemperature_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_annualTemperature_delta_old";
        INSERT INTO "dbrdf_annualTemperature_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_annualTemperature_delta_new" t0;
        TRUNCATE TABLE "dbrdf_annualTemperature_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_individualisedPnd_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_individualisedPnd_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_individualisedPnd" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_individualisedPnd_delta_old" ON "dbrdf_individualisedPnd_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_individualisedPnd_delta_old" ON "dbrdf_individualisedPnd_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_individualisedPnd_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_individualisedPnd"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_individualisedPnd_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_individualisedPnd_delta_old";
        INSERT INTO "dbrdf_individualisedPnd_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_individualisedPnd_delta_new" t0;
        TRUNCATE TABLE "dbrdf_individualisedPnd_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_secondPopularVote_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_secondPopularVote_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_secondPopularVote" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_secondPopularVote_delta_old" ON "dbrdf_secondPopularVote_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_secondPopularVote_delta_old" ON "dbrdf_secondPopularVote_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_secondPopularVote_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_secondPopularVote"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_secondPopularVote_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_secondPopularVote_delta_old";
        INSERT INTO "dbrdf_secondPopularVote_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_secondPopularVote_delta_new" t0;
        TRUNCATE TABLE "dbrdf_secondPopularVote_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_education_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_education_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_education" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_education_delta_old" ON "dbrdf_education_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_education_delta_old" ON "dbrdf_education_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_education_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    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_buildingStartDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_buildingStartDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_buildingStartDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_buildingStartDate_delta_old" ON "dbrdf_buildingStartDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_buildingStartDate_delta_old" ON "dbrdf_buildingStartDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_buildingStartDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_buildingStartDate"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_buildingStartDate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_buildingStartDate_delta_old";
        INSERT INTO "dbrdf_buildingStartDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_buildingStartDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_buildingStartDate_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_length_delta_old2"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_length_delta_old2"(s, o) SELECT t0.s, t0.o FROM "dbrdf_length2" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_length_delta_old2" ON "dbrdf_length_delta_old2"(s, o); CREATE INDEX "IDX_1_dbrdf_length_delta_old2" ON "dbrdf_length_delta_old2"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_length_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/Infrastructure/length$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Infrastructure/length$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_length_delta_new2"(s, o) SELECT t1.o, t0.o FROM "dbrdf_length_delta_old2" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_length2" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_length2"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_length_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_length_delta_old2";
        INSERT INTO "dbrdf_length_delta_old2"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_length_delta_new2" t0;
        TRUNCATE TABLE "dbrdf_length_delta_new2";

    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_facultySize_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_facultySize_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_facultySize" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_facultySize_delta_old" ON "dbrdf_facultySize_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_facultySize_delta_old" ON "dbrdf_facultySize_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_facultySize_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_facultySize"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_facultySize_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_facultySize_delta_old";
        INSERT INTO "dbrdf_facultySize_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_facultySize_delta_new" t0;
        TRUNCATE TABLE "dbrdf_facultySize_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_routeStartDirection_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_routeStartDirection_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_routeStartDirection" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_routeStartDirection_delta_old" ON "dbrdf_routeStartDirection_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_routeStartDirection_delta_old" ON "dbrdf_routeStartDirection_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_routeStartDirection_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_routeStartDirection"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_routeStartDirection_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_routeStartDirection_delta_old";
        INSERT INTO "dbrdf_routeStartDirection_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_routeStartDirection_delta_new" t0;
        TRUNCATE TABLE "dbrdf_routeStartDirection_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_mass_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mass_delta_old1"(s, o) SELECT t0.s, t0.o FROM "dbrdf_mass1" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mass_delta_old1" ON "dbrdf_mass_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_mass_delta_old1" ON "dbrdf_mass_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mass_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/Rocket/mass$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Rocket/mass$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_mass_delta_new1"(s, o) SELECT t1.o, t0.o FROM "dbrdf_mass_delta_old1" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_mass1" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_mass1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_mass_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_mass_delta_old1";
        INSERT INTO "dbrdf_mass_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_mass_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_mass_delta_new1";

    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_populationTotalRanking_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_populationTotalRanking_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_populationTotalRanking" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_populationTotalRanking_delta_old" ON "dbrdf_populationTotalRanking_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_populationTotalRanking_delta_old" ON "dbrdf_populationTotalRanking_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationTotalRanking_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_populationTotalRanking"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_populationTotalRanking_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_populationTotalRanking_delta_old";
        INSERT INTO "dbrdf_populationTotalRanking_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_populationTotalRanking_delta_new" t0;
        TRUNCATE TABLE "dbrdf_populationTotalRanking_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_numberOfLawyers_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfLawyers_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfLawyers" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfLawyers_delta_old" ON "dbrdf_numberOfLawyers_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfLawyers_delta_old" ON "dbrdf_numberOfLawyers_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfLawyers_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_numberOfLawyers"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfLawyers_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_numberOfLawyers_delta_old";
        INSERT INTO "dbrdf_numberOfLawyers_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfLawyers_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfLawyers_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_crosses_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_crosses_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_crosses" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_crosses_delta_old" ON "dbrdf_crosses_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_crosses_delta_old" ON "dbrdf_crosses_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_crosses_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_crosses"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_crosses_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_crosses_delta_old";
        INSERT INTO "dbrdf_crosses_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_crosses_delta_new" t0;
        TRUNCATE TABLE "dbrdf_crosses_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_usingCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_usingCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_usingCountry" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_usingCountry_delta_old" ON "dbrdf_usingCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_usingCountry_delta_old" ON "dbrdf_usingCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_usingCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_usingCountry"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_usingCountry_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_usingCountry_delta_old";
        INSERT INTO "dbrdf_usingCountry_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_usingCountry_delta_new" t0;
        TRUNCATE TABLE "dbrdf_usingCountry_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_undraftedYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_undraftedYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_undraftedYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_undraftedYear_delta_old" ON "dbrdf_undraftedYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_undraftedYear_delta_old" ON "dbrdf_undraftedYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_undraftedYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_undraftedYear"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_undraftedYear_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_undraftedYear_delta_old";
        INSERT INTO "dbrdf_undraftedYear_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_undraftedYear_delta_new" t0;
        TRUNCATE TABLE "dbrdf_undraftedYear_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_territory_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_territory_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_territory" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_territory_delta_old" ON "dbrdf_territory_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_territory_delta_old" ON "dbrdf_territory_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_territory_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_territory"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_territory_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_territory_delta_old";
        INSERT INTO "dbrdf_territory_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_territory_delta_new" t0;
        TRUNCATE TABLE "dbrdf_territory_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_governor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_governor_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_governor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_governor_delta_old" ON "dbrdf_governor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_governor_delta_old" ON "dbrdf_governor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_governor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_governor"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_governor_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_governor_delta_old";
        INSERT INTO "dbrdf_governor_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_governor_delta_new" t0;
        TRUNCATE TABLE "dbrdf_governor_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_discoverer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_discoverer_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_discoverer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_discoverer_delta_old" ON "dbrdf_discoverer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_discoverer_delta_old" ON "dbrdf_discoverer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_discoverer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_discoverer"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_discoverer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_discoverer_delta_old";
        INSERT INTO "dbrdf_discoverer_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_discoverer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_discoverer_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_icd9_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_icd9_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_icd9" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_icd9_delta_old" ON "dbrdf_icd9_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_icd9_delta_old" ON "dbrdf_icd9_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_icd9_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_icd9"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_icd9_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_icd9_delta_old";
        INSERT INTO "dbrdf_icd9_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_icd9_delta_new" t0;
        TRUNCATE TABLE "dbrdf_icd9_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_doctoralAdvisor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_doctoralAdvisor_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_doctoralAdvisor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_doctoralAdvisor_delta_old" ON "dbrdf_doctoralAdvisor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_doctoralAdvisor_delta_old" ON "dbrdf_doctoralAdvisor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_doctoralAdvisor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_doctoralAdvisor"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_doctoralAdvisor_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_doctoralAdvisor_delta_old";
        INSERT INTO "dbrdf_doctoralAdvisor_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_doctoralAdvisor_delta_new" t0;
        TRUNCATE TABLE "dbrdf_doctoralAdvisor_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_rebuildDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rebuildDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_rebuildDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rebuildDate_delta_old" ON "dbrdf_rebuildDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rebuildDate_delta_old" ON "dbrdf_rebuildDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rebuildDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_rebuildDate"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_rebuildDate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_rebuildDate_delta_old";
        INSERT INTO "dbrdf_rebuildDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_rebuildDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_rebuildDate_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_government_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_government_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_government" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_government_delta_old" ON "dbrdf_government_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_government_delta_old" ON "dbrdf_government_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_government_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_government"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_government_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_government_delta_old";
        INSERT INTO "dbrdf_government_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_government_delta_new" t0;
        TRUNCATE TABLE "dbrdf_government_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_goldenGlobeAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_goldenGlobeAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_goldenGlobeAward" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_goldenGlobeAward_delta_old" ON "dbrdf_goldenGlobeAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_goldenGlobeAward_delta_old" ON "dbrdf_goldenGlobeAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_goldenGlobeAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_goldenGlobeAward"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_goldenGlobeAward_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_goldenGlobeAward_delta_old";
        INSERT INTO "dbrdf_goldenGlobeAward_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_goldenGlobeAward_delta_new" t0;
        TRUNCATE TABLE "dbrdf_goldenGlobeAward_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_BaseballTeam_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_BaseballTeam_delta_old"(s) SELECT t0.s FROM "dbrdf_BaseballTeam" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_BaseballTeam_delta_old" ON "dbrdf_BaseballTeam_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_BaseballTeam_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/BaseballTeam$delta_new>(?Y) :- <http://dbpedia.org/ontology/BaseballTeam$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_BaseballTeam_delta_new"(s) SELECT t1.o FROM "dbrdf_BaseballTeam_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_BaseballTeam" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_BaseballTeam"(s) SELECT DISTINCT t0.s FROM "dbrdf_BaseballTeam_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_BaseballTeam_delta_old";
        INSERT INTO "dbrdf_BaseballTeam_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_BaseballTeam_delta_new" t0;
        TRUNCATE TABLE "dbrdf_BaseballTeam_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_imageSize_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_imageSize_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_imageSize" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_imageSize_delta_old" ON "dbrdf_imageSize_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_imageSize_delta_old" ON "dbrdf_imageSize_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_imageSize_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_imageSize"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_imageSize_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_imageSize_delta_old";
        INSERT INTO "dbrdf_imageSize_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_imageSize_delta_new" t0;
        TRUNCATE TABLE "dbrdf_imageSize_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_numberOfGoldMedalsWon_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfGoldMedalsWon_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfGoldMedalsWon" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfGoldMedalsWon_delta_old" ON "dbrdf_numberOfGoldMedalsWon_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfGoldMedalsWon_delta_old" ON "dbrdf_numberOfGoldMedalsWon_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfGoldMedalsWon_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_numberOfGoldMedalsWon"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfGoldMedalsWon_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_numberOfGoldMedalsWon_delta_old";
        INSERT INTO "dbrdf_numberOfGoldMedalsWon_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfGoldMedalsWon_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfGoldMedalsWon_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_militaryBranch_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_militaryBranch_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_militaryBranch" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_militaryBranch_delta_old" ON "dbrdf_militaryBranch_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_militaryBranch_delta_old" ON "dbrdf_militaryBranch_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_militaryBranch_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_militaryBranch"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_militaryBranch_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_militaryBranch_delta_old";
        INSERT INTO "dbrdf_militaryBranch_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_militaryBranch_delta_new" t0;
        TRUNCATE TABLE "dbrdf_militaryBranch_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_Non_ProfitOrganisation_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Non_ProfitOrganisation_delta_old"(s) SELECT t0.s FROM "dbrdf_Non_ProfitOrganisation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Non_ProfitOrganisation_delta_old" ON "dbrdf_Non_ProfitOrganisation_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Non_ProfitOrganisation_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/Non-ProfitOrganisation$delta_new>(?Y) :- <http://dbpedia.org/ontology/Non-ProfitOrganisation$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Non_ProfitOrganisation_delta_new"(s) SELECT t1.o FROM "dbrdf_Non_ProfitOrganisation_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Non_ProfitOrganisation" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Non_ProfitOrganisation"(s) SELECT DISTINCT t0.s FROM "dbrdf_Non_ProfitOrganisation_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Non_ProfitOrganisation_delta_old";
        INSERT INTO "dbrdf_Non_ProfitOrganisation_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Non_ProfitOrganisation_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Non_ProfitOrganisation_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_meshNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_meshNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_meshNumber" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_meshNumber_delta_old" ON "dbrdf_meshNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_meshNumber_delta_old" ON "dbrdf_meshNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_meshNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_meshNumber"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_meshNumber_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_meshNumber_delta_old";
        INSERT INTO "dbrdf_meshNumber_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_meshNumber_delta_new" t0;
        TRUNCATE TABLE "dbrdf_meshNumber_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_emedicineTopic_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_emedicineTopic_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_emedicineTopic" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_emedicineTopic_delta_old" ON "dbrdf_emedicineTopic_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_emedicineTopic_delta_old" ON "dbrdf_emedicineTopic_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_emedicineTopic_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    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_commissioningDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_commissioningDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_commissioningDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_commissioningDate_delta_old" ON "dbrdf_commissioningDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_commissioningDate_delta_old" ON "dbrdf_commissioningDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_commissioningDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_commissioningDate"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_commissioningDate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_commissioningDate_delta_old";
        INSERT INTO "dbrdf_commissioningDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_commissioningDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_commissioningDate_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_geology_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_geology_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_geology" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_geology_delta_old" ON "dbrdf_geology_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_geology_delta_old" ON "dbrdf_geology_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_geology_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_geology"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_geology_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_geology_delta_old";
        INSERT INTO "dbrdf_geology_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_geology_delta_new" t0;
        TRUNCATE TABLE "dbrdf_geology_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_drainsFrom_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_drainsFrom_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_drainsFrom" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_drainsFrom_delta_old" ON "dbrdf_drainsFrom_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_drainsFrom_delta_old" ON "dbrdf_drainsFrom_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_drainsFrom_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_drainsFrom"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_drainsFrom_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_drainsFrom_delta_old";
        INSERT INTO "dbrdf_drainsFrom_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_drainsFrom_delta_new" t0;
        TRUNCATE TABLE "dbrdf_drainsFrom_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_previousInfrastructure_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_previousInfrastructure_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_previousInfrastructure" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_previousInfrastructure_delta_old" ON "dbrdf_previousInfrastructure_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_previousInfrastructure_delta_old" ON "dbrdf_previousInfrastructure_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_previousInfrastructure_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_previousInfrastructure"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_previousInfrastructure_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_previousInfrastructure_delta_old";
        INSERT INTO "dbrdf_previousInfrastructure_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_previousInfrastructure_delta_new" t0;
        TRUNCATE TABLE "dbrdf_previousInfrastructure_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_distributingCompany_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_distributingCompany_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_distributingCompany" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_distributingCompany_delta_old" ON "dbrdf_distributingCompany_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_distributingCompany_delta_old" ON "dbrdf_distributingCompany_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_distributingCompany_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_distributingCompany"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_distributingCompany_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_distributingCompany_delta_old";
        INSERT INTO "dbrdf_distributingCompany_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_distributingCompany_delta_new" t0;
        TRUNCATE TABLE "dbrdf_distributingCompany_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_aircraftHelicopterAttack_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftHelicopterAttack_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_aircraftHelicopterAttack" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftHelicopterAttack_delta_old" ON "dbrdf_aircraftHelicopterAttack_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftHelicopterAttack_delta_old" ON "dbrdf_aircraftHelicopterAttack_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftHelicopterAttack_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_aircraftHelicopterAttack"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_aircraftHelicopterAttack_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_aircraftHelicopterAttack_delta_old";
        INSERT INTO "dbrdf_aircraftHelicopterAttack_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_aircraftHelicopterAttack_delta_new" t0;
        TRUNCATE TABLE "dbrdf_aircraftHelicopterAttack_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_politicGovernmentDepartment_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_politicGovernmentDepartment_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_politicGovernmentDepartment" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_politicGovernmentDepartment_delta_old" ON "dbrdf_politicGovernmentDepartment_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_politicGovernmentDepartment_delta_old" ON "dbrdf_politicGovernmentDepartment_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_politicGovernmentDepartment_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_politicGovernmentDepartment"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_politicGovernmentDepartment_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_politicGovernmentDepartment_delta_old";
        INSERT INTO "dbrdf_politicGovernmentDepartment_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_politicGovernmentDepartment_delta_new" t0;
        TRUNCATE TABLE "dbrdf_politicGovernmentDepartment_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_currentProduction_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_currentProduction_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_currentProduction" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_currentProduction_delta_old" ON "dbrdf_currentProduction_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_currentProduction_delta_old" ON "dbrdf_currentProduction_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_currentProduction_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_currentProduction"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_currentProduction_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_currentProduction_delta_old";
        INSERT INTO "dbrdf_currentProduction_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_currentProduction_delta_new" t0;
        TRUNCATE TABLE "dbrdf_currentProduction_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_meetingBuilding_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_meetingBuilding_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_meetingBuilding" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_meetingBuilding_delta_old" ON "dbrdf_meetingBuilding_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_meetingBuilding_delta_old" ON "dbrdf_meetingBuilding_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_meetingBuilding_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_meetingBuilding"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_meetingBuilding_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_meetingBuilding_delta_old";
        INSERT INTO "dbrdf_meetingBuilding_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_meetingBuilding_delta_new" t0;
        TRUNCATE TABLE "dbrdf_meetingBuilding_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_assistantPrincipal_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_assistantPrincipal_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_assistantPrincipal" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_assistantPrincipal_delta_old" ON "dbrdf_assistantPrincipal_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_assistantPrincipal_delta_old" ON "dbrdf_assistantPrincipal_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_assistantPrincipal_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_assistantPrincipal"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_assistantPrincipal_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_assistantPrincipal_delta_old";
        INSERT INTO "dbrdf_assistantPrincipal_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_assistantPrincipal_delta_new" t0;
        TRUNCATE TABLE "dbrdf_assistantPrincipal_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_numberOfLines_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfLines_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfLines" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfLines_delta_old" ON "dbrdf_numberOfLines_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfLines_delta_old" ON "dbrdf_numberOfLines_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfLines_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_numberOfLines"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfLines_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_numberOfLines_delta_old";
        INSERT INTO "dbrdf_numberOfLines_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfLines_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfLines_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_acquirementDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_acquirementDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_acquirementDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_acquirementDate_delta_old" ON "dbrdf_acquirementDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_acquirementDate_delta_old" ON "dbrdf_acquirementDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_acquirementDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_acquirementDate"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_acquirementDate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_acquirementDate_delta_old";
        INSERT INTO "dbrdf_acquirementDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_acquirementDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_acquirementDate_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_namedAfter_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_namedAfter_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_namedAfter" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_namedAfter_delta_old" ON "dbrdf_namedAfter_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_namedAfter_delta_old" ON "dbrdf_namedAfter_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_namedAfter_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_namedAfter"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_namedAfter_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_namedAfter_delta_old";
        INSERT INTO "dbrdf_namedAfter_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_namedAfter_delta_new" t0;
        TRUNCATE TABLE "dbrdf_namedAfter_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_railwayLineUsingTunnel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_railwayLineUsingTunnel_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_railwayLineUsingTunnel" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_railwayLineUsingTunnel_delta_old" ON "dbrdf_railwayLineUsingTunnel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_railwayLineUsingTunnel_delta_old" ON "dbrdf_railwayLineUsingTunnel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_railwayLineUsingTunnel_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 610
    ---- DEPENDS ON: 609, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/RailwayTunnel>(?X) :- <http://dbpedia.org/ontology/railwayLineUsingTunnel>(?X,?X1) .
    INSERT INTO "dbrdf_RailwayTunnel"(s) SELECT DISTINCT t0.s FROM "dbrdf_railwayLineUsingTunnel" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_RailwayTunnel" 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_RailwayTunnel_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_RailwayTunnel_delta_old"(s) SELECT t0.s FROM "dbrdf_RailwayTunnel" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_RailwayTunnel_delta_old" ON "dbrdf_RailwayTunnel_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_RailwayTunnel_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/RailwayTunnel$delta_new>(?Y) :- <http://dbpedia.org/ontology/RailwayTunnel$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_RailwayTunnel_delta_new"(s) SELECT t1.o FROM "dbrdf_RailwayTunnel_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_RailwayTunnel" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_RailwayTunnel"(s) SELECT DISTINCT t0.s FROM "dbrdf_RailwayTunnel_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_RailwayTunnel_delta_old";
        INSERT INTO "dbrdf_RailwayTunnel_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_RailwayTunnel_delta_new" t0;
        TRUNCATE TABLE "dbrdf_RailwayTunnel_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_rgbCoordinateRed_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rgbCoordinateRed_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_rgbCoordinateRed" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rgbCoordinateRed_delta_old" ON "dbrdf_rgbCoordinateRed_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rgbCoordinateRed_delta_old" ON "dbrdf_rgbCoordinateRed_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rgbCoordinateRed_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_rgbCoordinateRed"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_rgbCoordinateRed_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_rgbCoordinateRed_delta_old";
        INSERT INTO "dbrdf_rgbCoordinateRed_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_rgbCoordinateRed_delta_new" t0;
        TRUNCATE TABLE "dbrdf_rgbCoordinateRed_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_Fern_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Fern_delta_old"(s) SELECT t0.s FROM "dbrdf_Fern" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Fern_delta_old" ON "dbrdf_Fern_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Fern_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/Fern$delta_new>(?Y) :- <http://dbpedia.org/ontology/Fern$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Fern_delta_new"(s) SELECT t1.o FROM "dbrdf_Fern_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Fern" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Fern"(s) SELECT DISTINCT t0.s FROM "dbrdf_Fern_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Fern_delta_old";
        INSERT INTO "dbrdf_Fern_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Fern_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Fern_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_populationAsOf_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_populationAsOf_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_populationAsOf" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_populationAsOf_delta_old" ON "dbrdf_populationAsOf_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_populationAsOf_delta_old" ON "dbrdf_populationAsOf_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationAsOf_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_populationAsOf"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_populationAsOf_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_populationAsOf_delta_old";
        INSERT INTO "dbrdf_populationAsOf_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_populationAsOf_delta_new" t0;
        TRUNCATE TABLE "dbrdf_populationAsOf_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_reservations_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_reservations_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_reservations" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_reservations_delta_old" ON "dbrdf_reservations_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_reservations_delta_old" ON "dbrdf_reservations_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_reservations_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_reservations"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_reservations_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_reservations_delta_old";
        INSERT INTO "dbrdf_reservations_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_reservations_delta_new" t0;
        TRUNCATE TABLE "dbrdf_reservations_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_currentTeamMember_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_currentTeamMember_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_currentTeamMember" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_currentTeamMember_delta_old" ON "dbrdf_currentTeamMember_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_currentTeamMember_delta_old" ON "dbrdf_currentTeamMember_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_currentTeamMember_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_currentTeamMember"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_currentTeamMember_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_currentTeamMember_delta_old";
        INSERT INTO "dbrdf_currentTeamMember_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_currentTeamMember_delta_new" t0;
        TRUNCATE TABLE "dbrdf_currentTeamMember_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_principalArea_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_principalArea_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_principalArea" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_principalArea_delta_old" ON "dbrdf_principalArea_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_principalArea_delta_old" ON "dbrdf_principalArea_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_principalArea_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 617
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_legislativePeriodName_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_legislativePeriodName_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_legislativePeriodName" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_legislativePeriodName_delta_old" ON "dbrdf_legislativePeriodName_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_legislativePeriodName_delta_old" ON "dbrdf_legislativePeriodName_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_legislativePeriodName_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_legislativePeriodName"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_legislativePeriodName_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_legislativePeriodName_delta_old";
        INSERT INTO "dbrdf_legislativePeriodName_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_legislativePeriodName_delta_new" t0;
        TRUNCATE TABLE "dbrdf_legislativePeriodName_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_religiousHeadLabel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_religiousHeadLabel_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_religiousHeadLabel" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_religiousHeadLabel_delta_old" ON "dbrdf_religiousHeadLabel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_religiousHeadLabel_delta_old" ON "dbrdf_religiousHeadLabel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_religiousHeadLabel_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    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_mouthPlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mouthPlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_mouthPlace" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mouthPlace_delta_old" ON "dbrdf_mouthPlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mouthPlace_delta_old" ON "dbrdf_mouthPlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mouthPlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_mouthPlace"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_mouthPlace_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_mouthPlace_delta_old";
        INSERT INTO "dbrdf_mouthPlace_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_mouthPlace_delta_new" t0;
        TRUNCATE TABLE "dbrdf_mouthPlace_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_aircraftFighter_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftFighter_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_aircraftFighter" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftFighter_delta_old" ON "dbrdf_aircraftFighter_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftFighter_delta_old" ON "dbrdf_aircraftFighter_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftFighter_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_aircraftFighter"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_aircraftFighter_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_aircraftFighter_delta_old";
        INSERT INTO "dbrdf_aircraftFighter_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_aircraftFighter_delta_new" t0;
        TRUNCATE TABLE "dbrdf_aircraftFighter_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_railwayPlatforms_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_railwayPlatforms_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_railwayPlatforms" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_railwayPlatforms_delta_old" ON "dbrdf_railwayPlatforms_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_railwayPlatforms_delta_old" ON "dbrdf_railwayPlatforms_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_railwayPlatforms_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_railwayPlatforms"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_railwayPlatforms_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_railwayPlatforms_delta_old";
        INSERT INTO "dbrdf_railwayPlatforms_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_railwayPlatforms_delta_new" t0;
        TRUNCATE TABLE "dbrdf_railwayPlatforms_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_torqueOutput_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_torqueOutput_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_torqueOutput0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_torqueOutput_delta_old0" ON "dbrdf_torqueOutput_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_torqueOutput_delta_old0" ON "dbrdf_torqueOutput_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_torqueOutput_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_torqueOutput0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_torqueOutput_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_torqueOutput_delta_old0";
        INSERT INTO "dbrdf_torqueOutput_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_torqueOutput_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_torqueOutput_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_orbits_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_orbits_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_orbits" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_orbits_delta_old" ON "dbrdf_orbits_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_orbits_delta_old" ON "dbrdf_orbits_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_orbits_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_orbits"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_orbits_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_orbits_delta_old";
        INSERT INTO "dbrdf_orbits_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_orbits_delta_new" t0;
        TRUNCATE TABLE "dbrdf_orbits_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_Valley_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Valley_delta_old"(s) SELECT t0.s FROM "dbrdf_Valley" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Valley_delta_old" ON "dbrdf_Valley_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Valley_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/Valley$delta_new>(?Y) :- <http://dbpedia.org/ontology/Valley$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Valley_delta_new"(s) SELECT t1.o FROM "dbrdf_Valley_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Valley" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Valley"(s) SELECT DISTINCT t0.s FROM "dbrdf_Valley_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Valley_delta_old";
        INSERT INTO "dbrdf_Valley_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Valley_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Valley_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_populationPlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_populationPlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_populationPlace" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_populationPlace_delta_old" ON "dbrdf_populationPlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_populationPlace_delta_old" ON "dbrdf_populationPlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationPlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_populationPlace"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_populationPlace_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_populationPlace_delta_old";
        INSERT INTO "dbrdf_populationPlace_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_populationPlace_delta_new" t0;
        TRUNCATE TABLE "dbrdf_populationPlace_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_aircraftHelicopterUtility_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftHelicopterUtility_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_aircraftHelicopterUtility" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftHelicopterUtility_delta_old" ON "dbrdf_aircraftHelicopterUtility_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftHelicopterUtility_delta_old" ON "dbrdf_aircraftHelicopterUtility_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftHelicopterUtility_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_aircraftHelicopterUtility"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_aircraftHelicopterUtility_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_aircraftHelicopterUtility_delta_old";
        INSERT INTO "dbrdf_aircraftHelicopterUtility_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_aircraftHelicopterUtility_delta_new" t0;
        TRUNCATE TABLE "dbrdf_aircraftHelicopterUtility_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_prospectLeague_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_prospectLeague_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_prospectLeague" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_prospectLeague_delta_old" ON "dbrdf_prospectLeague_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_prospectLeague_delta_old" ON "dbrdf_prospectLeague_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_prospectLeague_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_prospectLeague"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_prospectLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_prospectLeague_delta_old";
        INSERT INTO "dbrdf_prospectLeague_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_prospectLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_prospectLeague_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_grammyAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_grammyAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_grammyAward" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_grammyAward_delta_old" ON "dbrdf_grammyAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_grammyAward_delta_old" ON "dbrdf_grammyAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_grammyAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 629
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_vehiclesPerDay_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_vehiclesPerDay_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_vehiclesPerDay" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_vehiclesPerDay_delta_old" ON "dbrdf_vehiclesPerDay_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_vehiclesPerDay_delta_old" ON "dbrdf_vehiclesPerDay_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_vehiclesPerDay_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_vehiclesPerDay"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_vehiclesPerDay_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_vehiclesPerDay_delta_old";
        INSERT INTO "dbrdf_vehiclesPerDay_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_vehiclesPerDay_delta_new" t0;
        TRUNCATE TABLE "dbrdf_vehiclesPerDay_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_restingPlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_restingPlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_restingPlace" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_restingPlace_delta_old" ON "dbrdf_restingPlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_restingPlace_delta_old" ON "dbrdf_restingPlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_restingPlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_restingPlace"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_restingPlace_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_restingPlace_delta_old";
        INSERT INTO "dbrdf_restingPlace_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_restingPlace_delta_new" t0;
        TRUNCATE TABLE "dbrdf_restingPlace_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_numberOfTerritories_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfTerritories_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfTerritories" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfTerritories_delta_old" ON "dbrdf_numberOfTerritories_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfTerritories_delta_old" ON "dbrdf_numberOfTerritories_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfTerritories_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_numberOfTerritories"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfTerritories_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_numberOfTerritories_delta_old";
        INSERT INTO "dbrdf_numberOfTerritories_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfTerritories_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfTerritories_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_taoiseach_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_taoiseach_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_taoiseach" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_taoiseach_delta_old" ON "dbrdf_taoiseach_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_taoiseach_delta_old" ON "dbrdf_taoiseach_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_taoiseach_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_taoiseach"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_taoiseach_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_taoiseach_delta_old";
        INSERT INTO "dbrdf_taoiseach_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_taoiseach_delta_new" t0;
        TRUNCATE TABLE "dbrdf_taoiseach_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_routeEnd_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_routeEnd_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_routeEnd" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_routeEnd_delta_old" ON "dbrdf_routeEnd_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_routeEnd_delta_old" ON "dbrdf_routeEnd_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_routeEnd_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_routeEnd"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_routeEnd_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_routeEnd_delta_old";
        INSERT INTO "dbrdf_routeEnd_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_routeEnd_delta_new" t0;
        TRUNCATE TABLE "dbrdf_routeEnd_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_geneLocationStart_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_geneLocationStart_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_geneLocationStart" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_geneLocationStart_delta_old" ON "dbrdf_geneLocationStart_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_geneLocationStart_delta_old" ON "dbrdf_geneLocationStart_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_geneLocationStart_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_geneLocationStart"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_geneLocationStart_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_geneLocationStart_delta_old";
        INSERT INTO "dbrdf_geneLocationStart_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_geneLocationStart_delta_new" t0;
        TRUNCATE TABLE "dbrdf_geneLocationStart_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_aspectRatio_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aspectRatio_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_aspectRatio" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aspectRatio_delta_old" ON "dbrdf_aspectRatio_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aspectRatio_delta_old" ON "dbrdf_aspectRatio_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aspectRatio_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_aspectRatio"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_aspectRatio_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_aspectRatio_delta_old";
        INSERT INTO "dbrdf_aspectRatio_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_aspectRatio_delta_new" t0;
        TRUNCATE TABLE "dbrdf_aspectRatio_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_BasketballTeam_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_BasketballTeam_delta_old"(s) SELECT t0.s FROM "dbrdf_BasketballTeam" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_BasketballTeam_delta_old" ON "dbrdf_BasketballTeam_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_BasketballTeam_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/BasketballTeam$delta_new>(?Y) :- <http://dbpedia.org/ontology/BasketballTeam$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_BasketballTeam_delta_new"(s) SELECT t1.o FROM "dbrdf_BasketballTeam_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_BasketballTeam" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_BasketballTeam"(s) SELECT DISTINCT t0.s FROM "dbrdf_BasketballTeam_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_BasketballTeam_delta_old";
        INSERT INTO "dbrdf_BasketballTeam_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_BasketballTeam_delta_new" t0;
        TRUNCATE TABLE "dbrdf_BasketballTeam_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_map_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_map_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_map" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_map_delta_old" ON "dbrdf_map_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_map_delta_old" ON "dbrdf_map_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_map_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_map"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_map_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_map_delta_old";
        INSERT INTO "dbrdf_map_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_map_delta_new" t0;
        TRUNCATE TABLE "dbrdf_map_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_europeanAffiliation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_europeanAffiliation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_europeanAffiliation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_europeanAffiliation_delta_old" ON "dbrdf_europeanAffiliation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_europeanAffiliation_delta_old" ON "dbrdf_europeanAffiliation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_europeanAffiliation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_europeanAffiliation"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_europeanAffiliation_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_europeanAffiliation_delta_old";
        INSERT INTO "dbrdf_europeanAffiliation_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_europeanAffiliation_delta_new" t0;
        TRUNCATE TABLE "dbrdf_europeanAffiliation_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_schoolBoard_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_schoolBoard_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_schoolBoard" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_schoolBoard_delta_old" ON "dbrdf_schoolBoard_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_schoolBoard_delta_old" ON "dbrdf_schoolBoard_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_schoolBoard_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_schoolBoard"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_schoolBoard_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_schoolBoard_delta_old";
        INSERT INTO "dbrdf_schoolBoard_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_schoolBoard_delta_new" t0;
        TRUNCATE TABLE "dbrdf_schoolBoard_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_firstFlightEndDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstFlightEndDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_firstFlightEndDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstFlightEndDate_delta_old" ON "dbrdf_firstFlightEndDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstFlightEndDate_delta_old" ON "dbrdf_firstFlightEndDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstFlightEndDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_firstFlightEndDate"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_firstFlightEndDate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_firstFlightEndDate_delta_old";
        INSERT INTO "dbrdf_firstFlightEndDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_firstFlightEndDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_firstFlightEndDate_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_stateDelegate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_stateDelegate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_stateDelegate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_stateDelegate_delta_old" ON "dbrdf_stateDelegate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_stateDelegate_delta_old" ON "dbrdf_stateDelegate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_stateDelegate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_stateDelegate"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_stateDelegate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_stateDelegate_delta_old";
        INSERT INTO "dbrdf_stateDelegate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_stateDelegate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_stateDelegate_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_Referee_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Referee_delta_old"(s) SELECT t0.s FROM "dbrdf_Referee" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Referee_delta_old" ON "dbrdf_Referee_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Referee_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/Referee$delta_new>(?Y) :- <http://dbpedia.org/ontology/Referee$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Referee_delta_new"(s) SELECT t1.o FROM "dbrdf_Referee_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Referee" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Referee"(s) SELECT DISTINCT t0.s FROM "dbrdf_Referee_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Referee_delta_old";
        INSERT INTO "dbrdf_Referee_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Referee_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Referee_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_president_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_president_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_president" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_president_delta_old" ON "dbrdf_president_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_president_delta_old" ON "dbrdf_president_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_president_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_president"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_president_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_president_delta_old";
        INSERT INTO "dbrdf_president_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_president_delta_new" t0;
        TRUNCATE TABLE "dbrdf_president_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_originalEndPoint_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_originalEndPoint_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_originalEndPoint" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_originalEndPoint_delta_old" ON "dbrdf_originalEndPoint_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_originalEndPoint_delta_old" ON "dbrdf_originalEndPoint_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_originalEndPoint_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_originalEndPoint"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_originalEndPoint_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_originalEndPoint_delta_old";
        INSERT INTO "dbrdf_originalEndPoint_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_originalEndPoint_delta_new" t0;
        TRUNCATE TABLE "dbrdf_originalEndPoint_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_raceLength_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_raceLength_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_raceLength" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_raceLength_delta_old" ON "dbrdf_raceLength_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_raceLength_delta_old" ON "dbrdf_raceLength_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_raceLength_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_raceLength"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_raceLength_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_raceLength_delta_old";
        INSERT INTO "dbrdf_raceLength_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_raceLength_delta_new" t0;
        TRUNCATE TABLE "dbrdf_raceLength_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_numberOfLaps_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfLaps_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfLaps" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfLaps_delta_old" ON "dbrdf_numberOfLaps_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfLaps_delta_old" ON "dbrdf_numberOfLaps_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfLaps_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_numberOfLaps"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfLaps_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_numberOfLaps_delta_old";
        INSERT INTO "dbrdf_numberOfLaps_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfLaps_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfLaps_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_rankingsDoubles_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rankingsDoubles_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_rankingsDoubles" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rankingsDoubles_delta_old" ON "dbrdf_rankingsDoubles_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rankingsDoubles_delta_old" ON "dbrdf_rankingsDoubles_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rankingsDoubles_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_rankingsDoubles"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_rankingsDoubles_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_rankingsDoubles_delta_old";
        INSERT INTO "dbrdf_rankingsDoubles_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_rankingsDoubles_delta_new" t0;
        TRUNCATE TABLE "dbrdf_rankingsDoubles_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_mainspan_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mainspan_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_mainspan" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mainspan_delta_old" ON "dbrdf_mainspan_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mainspan_delta_old" ON "dbrdf_mainspan_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mainspan_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_mainspan"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_mainspan_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_mainspan_delta_old";
        INSERT INTO "dbrdf_mainspan_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_mainspan_delta_new" t0;
        TRUNCATE TABLE "dbrdf_mainspan_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_automobilePlatform_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_automobilePlatform_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_automobilePlatform" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_automobilePlatform_delta_old" ON "dbrdf_automobilePlatform_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_automobilePlatform_delta_old" ON "dbrdf_automobilePlatform_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_automobilePlatform_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_automobilePlatform"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_automobilePlatform_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_automobilePlatform_delta_old";
        INSERT INTO "dbrdf_automobilePlatform_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_automobilePlatform_delta_new" t0;
        TRUNCATE TABLE "dbrdf_automobilePlatform_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_tvComId_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_tvComId_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_tvComId" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_tvComId_delta_old" ON "dbrdf_tvComId_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_tvComId_delta_old" ON "dbrdf_tvComId_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_tvComId_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_tvComId"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_tvComId_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_tvComId_delta_old";
        INSERT INTO "dbrdf_tvComId_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_tvComId_delta_new" t0;
        TRUNCATE TABLE "dbrdf_tvComId_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_birthName_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_birthName_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_birthName" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_birthName_delta_old" ON "dbrdf_birthName_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_birthName_delta_old" ON "dbrdf_birthName_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_birthName_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_birthName"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_birthName_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_birthName_delta_old";
        INSERT INTO "dbrdf_birthName_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_birthName_delta_new" t0;
        TRUNCATE TABLE "dbrdf_birthName_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_port1DockingDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_port1DockingDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_port1DockingDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_port1DockingDate_delta_old" ON "dbrdf_port1DockingDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_port1DockingDate_delta_old" ON "dbrdf_port1DockingDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_port1DockingDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_port1DockingDate"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_port1DockingDate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_port1DockingDate_delta_old";
        INSERT INTO "dbrdf_port1DockingDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_port1DockingDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_port1DockingDate_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_writer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_writer_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_writer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_writer_delta_old" ON "dbrdf_writer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_writer_delta_old" ON "dbrdf_writer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_writer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_writer"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_writer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_writer_delta_old";
        INSERT INTO "dbrdf_writer_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_writer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_writer_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_lunarSurfaceTime_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lunarSurfaceTime_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lunarSurfaceTime" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lunarSurfaceTime_delta_old" ON "dbrdf_lunarSurfaceTime_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lunarSurfaceTime_delta_old" ON "dbrdf_lunarSurfaceTime_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lunarSurfaceTime_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_lunarSurfaceTime"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lunarSurfaceTime_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_lunarSurfaceTime_delta_old";
        INSERT INTO "dbrdf_lunarSurfaceTime_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lunarSurfaceTime_delta_new" t0;
        TRUNCATE TABLE "dbrdf_lunarSurfaceTime_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_drainsTo_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_drainsTo_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_drainsTo" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_drainsTo_delta_old" ON "dbrdf_drainsTo_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_drainsTo_delta_old" ON "dbrdf_drainsTo_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_drainsTo_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_drainsTo"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_drainsTo_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_drainsTo_delta_old";
        INSERT INTO "dbrdf_drainsTo_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_drainsTo_delta_new" t0;
        TRUNCATE TABLE "dbrdf_drainsTo_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_temperature_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_temperature_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_temperature0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_temperature_delta_old0" ON "dbrdf_temperature_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_temperature_delta_old0" ON "dbrdf_temperature_delta_old0"(o);
