        INSERT INTO "dbrdf_summerAppearances_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_summerAppearances_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_summerAppearances" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1665
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsMainPart_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_alpsMainPart_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_alpsMainPart" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_alpsMainPart_delta_old" ON "dbrdf_alpsMainPart_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_alpsMainPart_delta_old" ON "dbrdf_alpsMainPart_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsMainPart_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1666
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_latestReleaseDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_latestReleaseDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_latestReleaseDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_latestReleaseDate_delta_old" ON "dbrdf_latestReleaseDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_latestReleaseDate_delta_old" ON "dbrdf_latestReleaseDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_latestReleaseDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1667
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lowest_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lowest_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lowest" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lowest_delta_old" ON "dbrdf_lowest_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lowest_delta_old" ON "dbrdf_lowest_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lowest_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1668
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_waterwayThroughTunnel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_waterwayThroughTunnel_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_waterwayThroughTunnel" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_waterwayThroughTunnel_delta_old" ON "dbrdf_waterwayThroughTunnel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_waterwayThroughTunnel_delta_old" ON "dbrdf_waterwayThroughTunnel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_waterwayThroughTunnel_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1669
    ---- DEPENDS ON: 1668, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/WaterwayTunnel>(?X) :- <http://dbpedia.org/ontology/waterwayThroughTunnel>(?X,?X1) .
    INSERT INTO "dbrdf_WaterwayTunnel"(s) SELECT DISTINCT t0.s FROM "dbrdf_waterwayThroughTunnel" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_WaterwayTunnel" 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_WaterwayTunnel_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_WaterwayTunnel_delta_old"(s) SELECT t0.s FROM "dbrdf_WaterwayTunnel" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_WaterwayTunnel_delta_old" ON "dbrdf_WaterwayTunnel_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_WaterwayTunnel_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/WaterwayTunnel$delta_new>(?Y) :- <http://dbpedia.org/ontology/WaterwayTunnel$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_WaterwayTunnel_delta_new"(s) SELECT t1.o FROM "dbrdf_WaterwayTunnel_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_WaterwayTunnel" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_WaterwayTunnel"(s) SELECT DISTINCT t0.s FROM "dbrdf_WaterwayTunnel_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_WaterwayTunnel_delta_old";
        INSERT INTO "dbrdf_WaterwayTunnel_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_WaterwayTunnel_delta_new" t0;
        TRUNCATE TABLE "dbrdf_WaterwayTunnel_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1670
    ---- DEPENDS ON: 1061, 1669, 241, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Tunnel"(s) SELECT DISTINCT t0.s FROM "dbrdf_Tunnel_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Tunnel_delta_old";
        INSERT INTO "dbrdf_Tunnel_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Tunnel_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Tunnel_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1671
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_flyingHours_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_flyingHours_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_flyingHours" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_flyingHours_delta_old" ON "dbrdf_flyingHours_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_flyingHours_delta_old" ON "dbrdf_flyingHours_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_flyingHours_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1672
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_weight_delta_old2"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_weight_delta_old2"(s, o) SELECT t0.s, t0.o FROM "dbrdf_weight2" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_weight_delta_old2" ON "dbrdf_weight_delta_old2"(s, o); CREATE INDEX "IDX_1_dbrdf_weight_delta_old2" ON "dbrdf_weight_delta_old2"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_weight_delta_new2"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_weight2"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_weight_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_weight_delta_old2";
        INSERT INTO "dbrdf_weight_delta_old2"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_weight_delta_new2" t0;
        TRUNCATE TABLE "dbrdf_weight_delta_new2";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1673
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_originalMaximumBoatLength0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_originalMaximumBoatLength_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_originalMaximumBoatLength_delta_old0";
        INSERT INTO "dbrdf_originalMaximumBoatLength_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_originalMaximumBoatLength_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_originalMaximumBoatLength_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1674
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mergedIntoParty_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mergedIntoParty_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_mergedIntoParty" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mergedIntoParty_delta_old" ON "dbrdf_mergedIntoParty_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mergedIntoParty_delta_old" ON "dbrdf_mergedIntoParty_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mergedIntoParty_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1675
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_titleDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_titleDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_titleDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_titleDate_delta_old" ON "dbrdf_titleDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_titleDate_delta_old" ON "dbrdf_titleDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_titleDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1676
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_governmentPosition_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_governmentPosition_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_governmentPosition" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_governmentPosition_delta_old" ON "dbrdf_governmentPosition_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_governmentPosition_delta_old" ON "dbrdf_governmentPosition_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_governmentPosition_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1677
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_tonyAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_tonyAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_tonyAward" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_tonyAward_delta_old" ON "dbrdf_tonyAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_tonyAward_delta_old" ON "dbrdf_tonyAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_tonyAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1678
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rebuildingYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rebuildingYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_rebuildingYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rebuildingYear_delta_old" ON "dbrdf_rebuildingYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rebuildingYear_delta_old" ON "dbrdf_rebuildingYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rebuildingYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1679
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_draftPick_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_draftPick_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_draftPick" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_draftPick_delta_old" ON "dbrdf_draftPick_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_draftPick_delta_old" ON "dbrdf_draftPick_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_draftPick_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1680
    ---- DEPENDS ON: 1679, 1529, 1505, 1168, 684, 537, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1681
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_albedo_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_albedo_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_albedo" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_albedo_delta_old" ON "dbrdf_albedo_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_albedo_delta_old" ON "dbrdf_albedo_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_albedo_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1682
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_identificationSymbol_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_identificationSymbol_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_identificationSymbol" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_identificationSymbol_delta_old" ON "dbrdf_identificationSymbol_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_identificationSymbol_delta_old" ON "dbrdf_identificationSymbol_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_identificationSymbol_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1683
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_whaDraftTeam_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_whaDraftTeam_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_whaDraftTeam" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_whaDraftTeam_delta_old" ON "dbrdf_whaDraftTeam_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_whaDraftTeam_delta_old" ON "dbrdf_whaDraftTeam_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_whaDraftTeam_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1684
    ---- DEPENDS ON: 1683, 1432, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_HockeyTeam"(s) SELECT DISTINCT t0.s FROM "dbrdf_HockeyTeam_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_HockeyTeam_delta_old";
        INSERT INTO "dbrdf_HockeyTeam_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_HockeyTeam_delta_new" t0;
        TRUNCATE TABLE "dbrdf_HockeyTeam_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1685
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_precursor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_precursor_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_precursor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_precursor_delta_old" ON "dbrdf_precursor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_precursor_delta_old" ON "dbrdf_precursor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_precursor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1686
    ---- DEPENDS ON: 1685, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Embryology"(s) SELECT DISTINCT t0.s FROM "dbrdf_Embryology_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Embryology_delta_old";
        INSERT INTO "dbrdf_Embryology_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Embryology_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Embryology_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1687
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1688
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_manxName_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_manxName_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_manxName" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_manxName_delta_old" ON "dbrdf_manxName_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_manxName_delta_old" ON "dbrdf_manxName_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_manxName_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1689
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_daylightSavingTimeZone_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_daylightSavingTimeZone_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_daylightSavingTimeZone" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_daylightSavingTimeZone_delta_old" ON "dbrdf_daylightSavingTimeZone_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_daylightSavingTimeZone_delta_old" ON "dbrdf_daylightSavingTimeZone_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_daylightSavingTimeZone_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1690
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lowerAge_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lowerAge_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lowerAge" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lowerAge_delta_old" ON "dbrdf_lowerAge_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lowerAge_delta_old" ON "dbrdf_lowerAge_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lowerAge_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1691
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_launchPad_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_launchPad_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_launchPad" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_launchPad_delta_old" ON "dbrdf_launchPad_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_launchPad_delta_old" ON "dbrdf_launchPad_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_launchPad_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1692
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumElevation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_maximumElevation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_maximumElevation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_maximumElevation_delta_old" ON "dbrdf_maximumElevation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_maximumElevation_delta_old" ON "dbrdf_maximumElevation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumElevation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1693
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_associateEditor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_associateEditor_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_associateEditor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_associateEditor_delta_old" ON "dbrdf_associateEditor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_associateEditor_delta_old" ON "dbrdf_associateEditor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_associateEditor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1694
    ---- DEPENDS ON: 1693, 1119, 659, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Newspaper>(?X) :- <http://dbpedia.org/ontology/sisterNewspaper>(?X,?X1) .
    INSERT INTO "dbrdf_Newspaper"(s) SELECT DISTINCT t0.s FROM "dbrdf_sisterNewspaper" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Newspaper" 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_Newspaper_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Newspaper_delta_old"(s) SELECT t0.s FROM "dbrdf_Newspaper" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Newspaper_delta_old" ON "dbrdf_Newspaper_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Newspaper_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/Newspaper$delta_new>(?Y) :- <http://dbpedia.org/ontology/Newspaper$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Newspaper_delta_new"(s) SELECT t1.o FROM "dbrdf_Newspaper_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Newspaper" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Newspaper"(s) SELECT DISTINCT t0.s FROM "dbrdf_Newspaper_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Newspaper_delta_old";
        INSERT INTO "dbrdf_Newspaper_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Newspaper_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Newspaper_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1695
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_currentRank_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_currentRank_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_currentRank" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_currentRank_delta_old" ON "dbrdf_currentRank_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_currentRank_delta_old" ON "dbrdf_currentRank_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_currentRank_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1696
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_LacrosseLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_LacrosseLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_LacrosseLeague_delta_old";
        INSERT INTO "dbrdf_LacrosseLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_LacrosseLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_LacrosseLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1697
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_BaseballLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_BaseballLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_BaseballLeague_delta_old";
        INSERT INTO "dbrdf_BaseballLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_BaseballLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_BaseballLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1698
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_significantProject_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_significantProject_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_significantProject" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_significantProject_delta_old" ON "dbrdf_significantProject_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_significantProject_delta_old" ON "dbrdf_significantProject_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_significantProject_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1699
    ---- DEPENDS ON: 1698, 807, 660, 653, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Architect"(s) SELECT DISTINCT t0.s FROM "dbrdf_Architect_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Architect_delta_old";
        INSERT INTO "dbrdf_Architect_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Architect_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Architect_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1700
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsSupergroup_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_alpsSupergroup_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_alpsSupergroup" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_alpsSupergroup_delta_old" ON "dbrdf_alpsSupergroup_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_alpsSupergroup_delta_old" ON "dbrdf_alpsSupergroup_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_alpsSupergroup_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1701
    ---- DEPENDS ON: 1700, 1665, 1478, 998, 943, 782, 771, 330, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_MountainRange"(s) SELECT DISTINCT t0.s FROM "dbrdf_MountainRange_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_MountainRange_delta_old";
        INSERT INTO "dbrdf_MountainRange_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_MountainRange_delta_new" t0;
        TRUNCATE TABLE "dbrdf_MountainRange_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1702
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Mineral"(s) SELECT DISTINCT t0.s FROM "dbrdf_Mineral_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Mineral_delta_old";
        INSERT INTO "dbrdf_Mineral_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Mineral_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Mineral_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1703
    ---- DEPENDS ON: 1702, 1058, 791, 578, 477, 107, 1080, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/ChemicalSubstance>(?X) :- <http://dbpedia.org/ontology/ChemicalCompound>(?X) .
    INSERT INTO "dbrdf_ChemicalSubstance"(s) SELECT t0.s FROM "dbrdf_ChemicalCompound" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_ChemicalSubstance" 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_ChemicalSubstance_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ChemicalSubstance_delta_old"(s) SELECT t0.s FROM "dbrdf_ChemicalSubstance" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ChemicalSubstance_delta_old" ON "dbrdf_ChemicalSubstance_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ChemicalSubstance_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/ChemicalSubstance$delta_new>(?Y) :- <http://dbpedia.org/ontology/ChemicalSubstance$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_ChemicalSubstance_delta_new"(s) SELECT t1.o FROM "dbrdf_ChemicalSubstance_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_ChemicalSubstance" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_ChemicalSubstance"(s) SELECT DISTINCT t0.s FROM "dbrdf_ChemicalSubstance_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_ChemicalSubstance_delta_old";
        INSERT INTO "dbrdf_ChemicalSubstance_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_ChemicalSubstance_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ChemicalSubstance_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1704
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lifeExpectancy_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lifeExpectancy_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lifeExpectancy" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lifeExpectancy_delta_old" ON "dbrdf_lifeExpectancy_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lifeExpectancy_delta_old" ON "dbrdf_lifeExpectancy_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lifeExpectancy_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1705
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_notableFeatures_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_notableFeatures_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_notableFeatures" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_notableFeatures_delta_old" ON "dbrdf_notableFeatures_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_notableFeatures_delta_old" ON "dbrdf_notableFeatures_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_notableFeatures_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1706
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sportSpecialty_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sportSpecialty_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_sportSpecialty" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sportSpecialty_delta_old" ON "dbrdf_sportSpecialty_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sportSpecialty_delta_old" ON "dbrdf_sportSpecialty_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sportSpecialty_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1707
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1708
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_maidenVoyage_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_maidenVoyage_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_maidenVoyage" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_maidenVoyage_delta_old" ON "dbrdf_maidenVoyage_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_maidenVoyage_delta_old" ON "dbrdf_maidenVoyage_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_maidenVoyage_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1709
    ---- DEPENDS ON: 1708, 1396, 1350, 1059, 1036, 1019, 889, 882, 790, 728, 687, 389, 232, 205, 174, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Ship>(?X) :- <http://dbpedia.org/ontology/recommissioningDate>(?X,?X1) .
    INSERT INTO "dbrdf_Ship"(s) SELECT DISTINCT t0.s FROM "dbrdf_recommissioningDate" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Ship" 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_Ship_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Ship_delta_old"(s) SELECT t0.s FROM "dbrdf_Ship" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Ship_delta_old" ON "dbrdf_Ship_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Ship_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/Ship$delta_new>(?Y) :- <http://dbpedia.org/ontology/Ship$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Ship_delta_new"(s) SELECT t1.o FROM "dbrdf_Ship_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Ship" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Ship"(s) SELECT DISTINCT t0.s FROM "dbrdf_Ship_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Ship_delta_old";
        INSERT INTO "dbrdf_Ship_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Ship_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Ship_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1710
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1711
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Insect"(s) SELECT DISTINCT t0.s FROM "dbrdf_Insect_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Insect_delta_old";
        INSERT INTO "dbrdf_Insect_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Insect_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Insect_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1712
    ---- DEPENDS ON: 1711, 1470, 1449, 1358, 1294, 620, 601, 417, 334, 324, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Animal>(?X) :- <http://dbpedia.org/ontology/Mammal>(?X) .
    INSERT INTO "dbrdf_Animal"(s) SELECT t0.s FROM "dbrdf_Mammal" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Animal" 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_Animal_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Animal_delta_old"(s) SELECT t0.s FROM "dbrdf_Animal" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Animal_delta_old" ON "dbrdf_Animal_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Animal_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/Animal$delta_new>(?Y) :- <http://dbpedia.org/ontology/Animal$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Animal_delta_new"(s) SELECT t1.o FROM "dbrdf_Animal_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Animal" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Animal"(s) SELECT DISTINCT t0.s FROM "dbrdf_Animal_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Animal_delta_old";
        INSERT INTO "dbrdf_Animal_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Animal_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Animal_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1713
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_recentWinner_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_recentWinner_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_recentWinner" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_recentWinner_delta_old" ON "dbrdf_recentWinner_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_recentWinner_delta_old" ON "dbrdf_recentWinner_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_recentWinner_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1714
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_whaDraft_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_whaDraft_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_whaDraft" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_whaDraft_delta_old" ON "dbrdf_whaDraft_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_whaDraft_delta_old" ON "dbrdf_whaDraft_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_whaDraft_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1715
    ---- DEPENDS ON: 1714, 1683, 1432, 1192, 1039, 474, 281, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/IceHockeyPlayer>(?X) :- <http://dbpedia.org/ontology/prospectLeague>(?X,?X1) .
    INSERT INTO "dbrdf_IceHockeyPlayer"(s) SELECT DISTINCT t0.s FROM "dbrdf_prospectLeague" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_IceHockeyPlayer" 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_IceHockeyPlayer_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_IceHockeyPlayer_delta_old"(s) SELECT t0.s FROM "dbrdf_IceHockeyPlayer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_IceHockeyPlayer_delta_old" ON "dbrdf_IceHockeyPlayer_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_IceHockeyPlayer_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/IceHockeyPlayer$delta_new>(?Y) :- <http://dbpedia.org/ontology/IceHockeyPlayer$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_IceHockeyPlayer_delta_new"(s) SELECT t1.o FROM "dbrdf_IceHockeyPlayer_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_IceHockeyPlayer" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_IceHockeyPlayer"(s) SELECT DISTINCT t0.s FROM "dbrdf_IceHockeyPlayer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_IceHockeyPlayer_delta_old";
        INSERT INTO "dbrdf_IceHockeyPlayer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_IceHockeyPlayer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_IceHockeyPlayer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1716
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_philosophicalSchool_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_philosophicalSchool_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_philosophicalSchool" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_philosophicalSchool_delta_old" ON "dbrdf_philosophicalSchool_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_philosophicalSchool_delta_old" ON "dbrdf_philosophicalSchool_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_philosophicalSchool_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1717
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_tenant_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_tenant_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_tenant" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_tenant_delta_old" ON "dbrdf_tenant_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_tenant_delta_old" ON "dbrdf_tenant_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_tenant_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1718
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1719
    ---- DEPENDS ON: 1718, 1511, 1169, 835, 740, 623, 428, 419, 388, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/MilitaryConflict>(?X) :- <http://dbpedia.org/ontology/strength>(?X,?X1) .
    INSERT INTO "dbrdf_MilitaryConflict"(s) SELECT DISTINCT t0.s FROM "dbrdf_strength" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_MilitaryConflict" 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_MilitaryConflict_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_MilitaryConflict_delta_old"(s) SELECT t0.s FROM "dbrdf_MilitaryConflict" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_MilitaryConflict_delta_old" ON "dbrdf_MilitaryConflict_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_MilitaryConflict_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/MilitaryConflict$delta_new>(?Y) :- <http://dbpedia.org/ontology/MilitaryConflict$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_MilitaryConflict_delta_new"(s) SELECT t1.o FROM "dbrdf_MilitaryConflict_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_MilitaryConflict" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_MilitaryConflict"(s) SELECT DISTINCT t0.s FROM "dbrdf_MilitaryConflict_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_MilitaryConflict_delta_old";
        INSERT INTO "dbrdf_MilitaryConflict_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_MilitaryConflict_delta_new" t0;
        TRUNCATE TABLE "dbrdf_MilitaryConflict_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1720
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_associateStar_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_associateStar_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_associateStar" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_associateStar_delta_old" ON "dbrdf_associateStar_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_associateStar_delta_old" ON "dbrdf_associateStar_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_associateStar_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1721
    ---- DEPENDS ON: 1720, 1535, 1400, 610, 553, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Constellation>(?X) :- <http://dbpedia.org/ontology/rightAscension>(?X,?X1) .
    INSERT INTO "dbrdf_Constellation"(s) SELECT DISTINCT t0.s FROM "dbrdf_rightAscension" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Constellation" 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_Constellation_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Constellation_delta_old"(s) SELECT t0.s FROM "dbrdf_Constellation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Constellation_delta_old" ON "dbrdf_Constellation_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Constellation_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/Constellation$delta_new>(?Y) :- <http://dbpedia.org/ontology/Constellation$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Constellation_delta_new"(s) SELECT t1.o FROM "dbrdf_Constellation_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Constellation" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Constellation"(s) SELECT DISTINCT t0.s FROM "dbrdf_Constellation_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Constellation_delta_old";
        INSERT INTO "dbrdf_Constellation_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Constellation_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Constellation_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1722
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_parkingInformation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_parkingInformation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_parkingInformation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_parkingInformation_delta_old" ON "dbrdf_parkingInformation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_parkingInformation_delta_old" ON "dbrdf_parkingInformation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_parkingInformation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1723
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_hairColor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_hairColor_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_hairColor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_hairColor_delta_old" ON "dbrdf_hairColor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_hairColor_delta_old" ON "dbrdf_hairColor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_hairColor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1724
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_introduced_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_introduced_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_introduced" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_introduced_delta_old" ON "dbrdf_introduced_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_introduced_delta_old" ON "dbrdf_introduced_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_introduced_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1725
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Chancellor"(s) SELECT DISTINCT t0.s FROM "dbrdf_Chancellor_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Chancellor_delta_old";
        INSERT INTO "dbrdf_Chancellor_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Chancellor_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Chancellor_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1726
    ---- DEPENDS ON: 1725, 1107, 987, 949, 873, 639, 368, 304, 275, 146, 84, 68, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Politician>(?X) :- <http://dbpedia.org/ontology/VicePresident>(?X) .
    INSERT INTO "dbrdf_Politician"(s) SELECT t0.s FROM "dbrdf_VicePresident" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Politician" 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_Politician_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Politician_delta_old"(s) SELECT t0.s FROM "dbrdf_Politician" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Politician_delta_old" ON "dbrdf_Politician_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Politician_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/Politician$delta_new>(?Y) :- <http://dbpedia.org/ontology/Politician$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Politician_delta_new"(s) SELECT t1.o FROM "dbrdf_Politician_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Politician" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Politician"(s) SELECT DISTINCT t0.s FROM "dbrdf_Politician_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Politician_delta_old";
        INSERT INTO "dbrdf_Politician_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Politician_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Politician_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1727
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_alliance_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_alliance_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_alliance" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_alliance_delta_old" ON "dbrdf_alliance_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_alliance_delta_old" ON "dbrdf_alliance_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_alliance_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1728
    ---- DEPENDS ON: 1727, 712, 453, 213, 14, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Airline>(?X) :- <http://dbpedia.org/ontology/destination>(?X,?X1) .
    INSERT INTO "dbrdf_Airline"(s) SELECT DISTINCT t0.s FROM "dbrdf_destination" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Airline" 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_Airline_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Airline_delta_old"(s) SELECT t0.s FROM "dbrdf_Airline" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Airline_delta_old" ON "dbrdf_Airline_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Airline_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/Airline$delta_new>(?Y) :- <http://dbpedia.org/ontology/Airline$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Airline_delta_new"(s) SELECT t1.o FROM "dbrdf_Airline_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Airline" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Airline"(s) SELECT DISTINCT t0.s FROM "dbrdf_Airline_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Airline_delta_old";
        INSERT INTO "dbrdf_Airline_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Airline_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Airline_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1729
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_youthClub_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_youthClub_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_youthClub" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_youthClub_delta_old" ON "dbrdf_youthClub_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_youthClub_delta_old" ON "dbrdf_youthClub_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_youthClub_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1730
    ---- DEPENDS ON: 1179, 566, 468, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/RecordLabel>(?X) :- <http://dbpedia.org/ontology/distributingLabel>(?X,?X1) .
    INSERT INTO "dbrdf_RecordLabel"(s) SELECT DISTINCT t0.s FROM "dbrdf_distributingLabel" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_RecordLabel" 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_RecordLabel_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_RecordLabel_delta_old"(s) SELECT t0.s FROM "dbrdf_RecordLabel" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_RecordLabel_delta_old" ON "dbrdf_RecordLabel_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_RecordLabel_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/RecordLabel$delta_new>(?Y) :- <http://dbpedia.org/ontology/RecordLabel$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_RecordLabel_delta_new"(s) SELECT t1.o FROM "dbrdf_RecordLabel_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_RecordLabel" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_RecordLabel"(s) SELECT DISTINCT t0.s FROM "dbrdf_RecordLabel_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_RecordLabel_delta_old";
        INSERT INTO "dbrdf_RecordLabel_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_RecordLabel_delta_new" t0;
        TRUNCATE TABLE "dbrdf_RecordLabel_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1731
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_releaseDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_releaseDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_releaseDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_releaseDate_delta_old" ON "dbrdf_releaseDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_releaseDate_delta_old" ON "dbrdf_releaseDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_releaseDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1732
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_fastestDriverCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_fastestDriverCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_fastestDriverCountry" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_fastestDriverCountry_delta_old" ON "dbrdf_fastestDriverCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_fastestDriverCountry_delta_old" ON "dbrdf_fastestDriverCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_fastestDriverCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1733
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_centuryBreaks_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_centuryBreaks_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_centuryBreaks" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_centuryBreaks_delta_old" ON "dbrdf_centuryBreaks_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_centuryBreaks_delta_old" ON "dbrdf_centuryBreaks_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_centuryBreaks_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1734
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_surfaceArea0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_surfaceArea_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_surfaceArea_delta_old0";
        INSERT INTO "dbrdf_surfaceArea_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_surfaceArea_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_surfaceArea_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1735
    ---- DEPENDS ON: 1421, 1287, 849, 839, 796, 487, 446, 398, 392, 191, 144, 38, 3, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

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

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Language"(s) SELECT DISTINCT t0.s FROM "dbrdf_Language_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Language_delta_old";
        INSERT INTO "dbrdf_Language_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Language_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Language_delta_new";

        INSERT INTO "dbrdf_Language0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Language_delta_new0" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Language_delta_old0";
        INSERT INTO "dbrdf_Language_delta_old0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Language_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_Language_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1736
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1737
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1738
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1739
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1740
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1741
    ---- DEPENDS ON: 1740, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Letter>(?X) :- <http://dbpedia.org/ontology/unicode>(?X,?X1) .
    INSERT INTO "dbrdf_Letter"(s) SELECT DISTINCT t0.s FROM "dbrdf_unicode" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Letter" 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_Letter_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Letter_delta_old"(s) SELECT t0.s FROM "dbrdf_Letter" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Letter_delta_old" ON "dbrdf_Letter_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Letter_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Letter"(s) SELECT DISTINCT t0.s FROM "dbrdf_Letter_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Letter_delta_old";
        INSERT INTO "dbrdf_Letter_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Letter_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Letter_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1742
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1743
    ---- DEPENDS ON: 1742, 1198, 589, 576, 536, 261, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/CollegeCoach>(?X) :- <http://dbpedia.org/ontology/tournamentRecord>(?X,?X1) .
    INSERT INTO "dbrdf_CollegeCoach"(s) SELECT DISTINCT t0.s FROM "dbrdf_tournamentRecord" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_CollegeCoach" 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_CollegeCoach_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_CollegeCoach_delta_old"(s) SELECT t0.s FROM "dbrdf_CollegeCoach" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_CollegeCoach_delta_old" ON "dbrdf_CollegeCoach_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_CollegeCoach_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/CollegeCoach$delta_new>(?Y) :- <http://dbpedia.org/ontology/CollegeCoach$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_CollegeCoach_delta_new"(s) SELECT t1.o FROM "dbrdf_CollegeCoach_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_CollegeCoach" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_CollegeCoach"(s) SELECT DISTINCT t0.s FROM "dbrdf_CollegeCoach_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_CollegeCoach_delta_old";
        INSERT INTO "dbrdf_CollegeCoach_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_CollegeCoach_delta_new" t0;
        TRUNCATE TABLE "dbrdf_CollegeCoach_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1744
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1745
    ---- DEPENDS ON: 1744, 1441, 1096, 837, 775, 697, 449, 418, 373, 158, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Play>(?X) :- <http://dbpedia.org/ontology/premiereDate>(?X,?X1) .
    INSERT INTO "dbrdf_Play"(s) SELECT DISTINCT t0.s FROM "dbrdf_premiereDate" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Play" 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_Play_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Play_delta_old"(s) SELECT t0.s FROM "dbrdf_Play" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Play_delta_old" ON "dbrdf_Play_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Play_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Play"(s) SELECT DISTINCT t0.s FROM "dbrdf_Play_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Play_delta_old";
        INSERT INTO "dbrdf_Play_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Play_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Play_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1746
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1747
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1748
    ---- DEPENDS ON: 1747, 1536, 1477, 1405, 1386, 1256, 1170, 1027, 925, 886, 718, 693, 636, 611, 568, 547, 504, 450, 443, 409, 310, 298, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Film>(?X) :- <http://dbpedia.org/ontology/filmPolskiId>(?X,?X1) .
    INSERT INTO "dbrdf_Film"(s) SELECT DISTINCT t0.s FROM "dbrdf_filmPolskiId" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Film" 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_Movie_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Movie_delta_old"(s) SELECT t0.s FROM "dbrdf_Movie" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Movie_delta_old" ON "dbrdf_Movie_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Movie_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Film_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Film_delta_old"(s) SELECT t0.s FROM "dbrdf_Film" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Film_delta_old" ON "dbrdf_Film_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Film_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/Movie$delta_new>(?X) :- <http://dbpedia.org/ontology/Film$delta_old>(?X) .
        INSERT INTO "dbrdf_Movie_delta_new"(s) SELECT t0.s FROM "dbrdf_Film_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Movie" ex WHERE ex.s = t0.s);


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


        -- <http://dbpedia.org/ontology/Film$delta_new>(?X) :- <http://schema.org/Movie$delta_old>(?X) .
        INSERT INTO "dbrdf_Film_delta_new"(s) SELECT t0.s FROM "dbrdf_Movie_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Film" ex WHERE ex.s = t0.s);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Movie"(s) SELECT DISTINCT t0.s FROM "dbrdf_Movie_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Movie_delta_old";
        INSERT INTO "dbrdf_Movie_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Movie_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Movie_delta_new";

        INSERT INTO "dbrdf_Film"(s) SELECT DISTINCT t0.s FROM "dbrdf_Film_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Film_delta_old";
        INSERT INTO "dbrdf_Film_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Film_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Film_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1749
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Asteroid_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Asteroid_delta_old"(s) SELECT t0.s FROM "dbrdf_Asteroid" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Asteroid_delta_old" ON "dbrdf_Asteroid_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Asteroid_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Asteroid"(s) SELECT DISTINCT t0.s FROM "dbrdf_Asteroid_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Asteroid_delta_old";
        INSERT INTO "dbrdf_Asteroid_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Asteroid_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Asteroid_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1750
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1751
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1752
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1753
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1754
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1755
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1756
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1757
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1758
    ---- DEPENDS ON: 1757, 1474, 1447, 1197, 1026, 1012, 844, 811, 804, 756, 563, 470, 395, 311, 239, 104, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/SpaceShuttle>(?X) :- <http://dbpedia.org/ontology/lastFlight>(?X,?X1) .
    INSERT INTO "dbrdf_SpaceShuttle"(s) SELECT DISTINCT t0.s FROM "dbrdf_lastFlight" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_SpaceShuttle" 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_SpaceShuttle_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SpaceShuttle_delta_old"(s) SELECT t0.s FROM "dbrdf_SpaceShuttle" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SpaceShuttle_delta_old" ON "dbrdf_SpaceShuttle_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SpaceShuttle_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/SpaceShuttle$delta_new>(?Y) :- <http://dbpedia.org/ontology/SpaceShuttle$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_SpaceShuttle_delta_new"(s) SELECT t1.o FROM "dbrdf_SpaceShuttle_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_SpaceShuttle" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_SpaceShuttle"(s) SELECT DISTINCT t0.s FROM "dbrdf_SpaceShuttle_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SpaceShuttle_delta_old";
        INSERT INTO "dbrdf_SpaceShuttle_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SpaceShuttle_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SpaceShuttle_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1759
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1760
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1761
    ---- DEPENDS ON: 1760, 1756, 1454, 1398, 1302, 1182, 1122, 885, 607, 560, 464, 180, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Colour>(?X) :- <http://dbpedia.org/ontology/wavelength>(?X,?X1) .
    INSERT INTO "dbrdf_Colour"(s) SELECT DISTINCT t0.s FROM "dbrdf_wavelength" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Colour" 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_Colour_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Colour_delta_old"(s) SELECT t0.s FROM "dbrdf_Colour" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Colour_delta_old" ON "dbrdf_Colour_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Colour_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/Colour$delta_new>(?Y) :- <http://dbpedia.org/ontology/Colour$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Colour_delta_new"(s) SELECT t1.o FROM "dbrdf_Colour_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Colour" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Colour"(s) SELECT DISTINCT t0.s FROM "dbrdf_Colour_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Colour_delta_old";
        INSERT INTO "dbrdf_Colour_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Colour_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Colour_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1762
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1763
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1764
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1765
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1766
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1767
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1768
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1769
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1770
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1771
    ---- DEPENDS ON: 1770, 1167, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1772
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1773
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1774
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1775
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1776
    ---- DEPENDS ON: 1775, 1746, 1673, 1630, 1463, 1429, 1313, 1307, 1202, 1134, 1132, 961, 893, 770, 656, 647, 572, 402, 335, 274, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Canal>(?X) :- <http://dbpedia.org/ontology/dateAct>(?X,?X1) .
    INSERT INTO "dbrdf_Canal0"(s) SELECT DISTINCT t0.s FROM "dbrdf_dateAct" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Canal0" 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_Canal_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Canal_delta_old"(s) SELECT t0.s FROM "dbrdf_Canal" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Canal_delta_old" ON "dbrdf_Canal_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Canal_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Canal_delta_old0"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Canal_delta_old0"(s) SELECT t0.s FROM "dbrdf_Canal0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Canal_delta_old0" ON "dbrdf_Canal_delta_old0"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Canal_delta_new0"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://schema.org/Canal$delta_new>(?X) :- <http://dbpedia.org/ontology/Canal$delta_old>(?X) .
        INSERT INTO "dbrdf_Canal_delta_new"(s) SELECT t0.s FROM "dbrdf_Canal_delta_old0" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Canal" ex WHERE ex.s = t0.s);


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


        -- <http://dbpedia.org/ontology/Canal$delta_new>(?X) :- <http://schema.org/Canal$delta_old>(?X) .
        INSERT INTO "dbrdf_Canal_delta_new0"(s) SELECT t0.s FROM "dbrdf_Canal_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Canal0" ex WHERE ex.s = t0.s);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Canal"(s) SELECT DISTINCT t0.s FROM "dbrdf_Canal_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Canal_delta_old";
        INSERT INTO "dbrdf_Canal_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Canal_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Canal_delta_new";

        INSERT INTO "dbrdf_Canal0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Canal_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_Canal_delta_old0";
        INSERT INTO "dbrdf_Canal_delta_old0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Canal_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_Canal_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1777
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1778
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1779
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1780
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1781
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1782
    ---- DEPENDS ON: 1781, 883, 134, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1783
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1784
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1785
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1786
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1787
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_gaelicName_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_gaelicName_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_gaelicName" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_gaelicName_delta_old" ON "dbrdf_gaelicName_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_gaelicName_delta_old" ON "dbrdf_gaelicName_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_gaelicName_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1788
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1789
    ---- DEPENDS ON: 1788, 1458, 1381, 1113, 743, 287, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1790
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1791
    ---- DEPENDS ON: 1790, 1664, 1600, 1594, 1385, 1352, 1330, 1136, 1028, 950, 905, 861, 230, 42, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/OlympicResult>(?X) :- <http://dbpedia.org/ontology/nationalOlympicCommittee>(?X,?X1) .
    INSERT INTO "dbrdf_OlympicResult"(s) SELECT DISTINCT t0.s FROM "dbrdf_nationalOlympicCommittee" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_OlympicResult" 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_OlympicResult_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_OlympicResult_delta_old"(s) SELECT t0.s FROM "dbrdf_OlympicResult" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_OlympicResult_delta_old" ON "dbrdf_OlympicResult_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_OlympicResult_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/OlympicResult$delta_new>(?Y) :- <http://dbpedia.org/ontology/OlympicResult$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_OlympicResult_delta_new"(s) SELECT t1.o FROM "dbrdf_OlympicResult_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_OlympicResult" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_OlympicResult"(s) SELECT DISTINCT t0.s FROM "dbrdf_OlympicResult_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_OlympicResult_delta_old";
        INSERT INTO "dbrdf_OlympicResult_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_OlympicResult_delta_new" t0;
        TRUNCATE TABLE "dbrdf_OlympicResult_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1792
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1793
    ---- DEPENDS ON: 1792, 1227, 1187, 958, 731, 720, 467, 367, 306, 237, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1794
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1795
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1796
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1797
    ---- DEPENDS ON: 1713, 1157, 988, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1798
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1799
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1800
    ---- DEPENDS ON: 1517, 1160, 1069, 968, 739, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/FigureSkater>(?X) :- <http://dbpedia.org/ontology/formerCoach>(?X,?X1) .
    INSERT INTO "dbrdf_FigureSkater"(s) SELECT DISTINCT t0.s FROM "dbrdf_formerCoach" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_FigureSkater" 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_FigureSkater_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_FigureSkater_delta_old"(s) SELECT t0.s FROM "dbrdf_FigureSkater" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_FigureSkater_delta_old" ON "dbrdf_FigureSkater_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_FigureSkater_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/FigureSkater$delta_new>(?Y) :- <http://dbpedia.org/ontology/FigureSkater$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_FigureSkater_delta_new"(s) SELECT t1.o FROM "dbrdf_FigureSkater_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_FigureSkater" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_FigureSkater"(s) SELECT DISTINCT t0.s FROM "dbrdf_FigureSkater_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_FigureSkater_delta_old";
        INSERT INTO "dbrdf_FigureSkater_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_FigureSkater_delta_new" t0;
        TRUNCATE TABLE "dbrdf_FigureSkater_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1801
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_omim_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_omim_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_omim" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_omim_delta_old" ON "dbrdf_omim_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_omim_delta_old" ON "dbrdf_omim_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_omim_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1802
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_artist_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_artist_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_artist" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_artist_delta_old" ON "dbrdf_artist_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_artist_delta_old" ON "dbrdf_artist_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_artist_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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