    CREATE INDEX "IDX_0_dbrdf_fate_delta_old" ON "dbrdf_fate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_fate_delta_old" ON "dbrdf_fate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_fate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    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_locationCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_locationCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_locationCountry" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_locationCountry_delta_old" ON "dbrdf_locationCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_locationCountry_delta_old" ON "dbrdf_locationCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_locationCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1800
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1801
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_serviceEndDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_serviceEndDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_serviceEndDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_serviceEndDate_delta_old" ON "dbrdf_serviceEndDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_serviceEndDate_delta_old" ON "dbrdf_serviceEndDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_serviceEndDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_serviceEndDate"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_serviceEndDate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_serviceEndDate_delta_old";
        INSERT INTO "dbrdf_serviceEndDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_serviceEndDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_serviceEndDate_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_ClubMoss_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ClubMoss_delta_old"(s) SELECT t0.s FROM "dbrdf_ClubMoss" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ClubMoss_delta_old" ON "dbrdf_ClubMoss_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ClubMoss_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1803
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_minimumTemperature_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_minimumTemperature_delta_old1"(s, o) SELECT t0.s, t0.o FROM "dbrdf_minimumTemperature1" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_minimumTemperature_delta_old1" ON "dbrdf_minimumTemperature_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_minimumTemperature_delta_old1" ON "dbrdf_minimumTemperature_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_minimumTemperature_delta_new1"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1804
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1805
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_debut_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_debut_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_debut" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_debut_delta_old" ON "dbrdf_debut_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_debut_delta_old" ON "dbrdf_debut_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_debut_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1806
    ---- DEPENDS ON: 1805, 732, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- [Rule] <http://dbpedia.org/ontology/Wrestler>(?X) :- <http://dbpedia.org/ontology/billed>(?X,?X1) .
    INSERT INTO "dbrdf_Wrestler"(s) SELECT DISTINCT t0.s FROM "dbrdf_billed" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Wrestler" 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_Wrestler_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Wrestler_delta_old"(s) SELECT t0.s FROM "dbrdf_Wrestler" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Wrestler_delta_old" ON "dbrdf_Wrestler_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Wrestler_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/Wrestler$delta_new>(?Y) :- <http://dbpedia.org/ontology/Wrestler$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Wrestler_delta_new"(s) SELECT t1.o FROM "dbrdf_Wrestler_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Wrestler" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Wrestler"(s) SELECT DISTINCT t0.s FROM "dbrdf_Wrestler_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Wrestler_delta_old";
        INSERT INTO "dbrdf_Wrestler_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Wrestler_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Wrestler_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1807
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_stationEvaDuration0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_stationEvaDuration_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_stationEvaDuration_delta_old0";
        INSERT INTO "dbrdf_stationEvaDuration_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_stationEvaDuration_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_stationEvaDuration_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1808
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_publisher_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_publisher_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_publisher" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_publisher_delta_old" ON "dbrdf_publisher_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_publisher_delta_old" ON "dbrdf_publisher_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_publisher_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1809
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_meanTemperature_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_meanTemperature_delta_old1"(s, o) SELECT t0.s, t0.o FROM "dbrdf_meanTemperature1" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_meanTemperature_delta_old1" ON "dbrdf_meanTemperature_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_meanTemperature_delta_old1" ON "dbrdf_meanTemperature_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_meanTemperature_delta_new1"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1810
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_layingDown_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_layingDown_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_layingDown" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_layingDown_delta_old" ON "dbrdf_layingDown_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_layingDown_delta_old" ON "dbrdf_layingDown_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_layingDown_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1811
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_slogan_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_slogan_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_slogan" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_slogan_delta_old" ON "dbrdf_slogan_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_slogan_delta_old" ON "dbrdf_slogan_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_slogan_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1812
    ---- DEPENDS ON: 1301, 239, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- [Rule] <http://dbpedia.org/ontology/Arena>(?X1) :- <http://dbpedia.org/ontology/homeArena>(?X,?X1) .
    INSERT INTO "dbrdf_Arena"(s) SELECT DISTINCT t0.o FROM "dbrdf_homeArena" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Arena" 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_Stadium_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Stadium_delta_old"(s) SELECT t0.s FROM "dbrdf_Stadium" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Stadium_delta_old" ON "dbrdf_Stadium_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Stadium_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_StadiumOrArena_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_StadiumOrArena_delta_old"(s) SELECT t0.s FROM "dbrdf_StadiumOrArena" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_StadiumOrArena_delta_old" ON "dbrdf_StadiumOrArena_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_StadiumOrArena_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Arena_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Arena_delta_old"(s) SELECT t0.s FROM "dbrdf_Arena" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Arena_delta_old" ON "dbrdf_Arena_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Arena_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/Stadium$delta_new>(?X) :- <http://schema.org/StadiumOrArena$delta_old>(?X) .
        INSERT INTO "dbrdf_Stadium_delta_new"(s) SELECT t0.s FROM "dbrdf_StadiumOrArena_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Stadium" ex WHERE ex.s = t0.s);


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


        -- <http://schema.org/StadiumOrArena$delta_new>(?X) :- <http://dbpedia.org/ontology/Arena$delta_old>(?X) .
        INSERT INTO "dbrdf_StadiumOrArena_delta_new"(s) SELECT t0.s FROM "dbrdf_Arena_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_StadiumOrArena" ex WHERE ex.s = t0.s);


        -- <http://schema.org/StadiumOrArena$delta_new>(?X) :- <http://dbpedia.org/ontology/Stadium$delta_old>(?X) .
        INSERT INTO "dbrdf_StadiumOrArena_delta_new"(s) SELECT t0.s FROM "dbrdf_Stadium_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_StadiumOrArena" ex WHERE ex.s = t0.s);


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


        -- <http://dbpedia.org/ontology/Arena$delta_new>(?X) :- <http://schema.org/StadiumOrArena$delta_old>(?X) .
        INSERT INTO "dbrdf_Arena_delta_new"(s) SELECT t0.s FROM "dbrdf_StadiumOrArena_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Arena" ex WHERE ex.s = t0.s);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Stadium"(s) SELECT DISTINCT t0.s FROM "dbrdf_Stadium_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Stadium_delta_old";
        INSERT INTO "dbrdf_Stadium_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Stadium_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Stadium_delta_new";

        INSERT INTO "dbrdf_StadiumOrArena"(s) SELECT DISTINCT t0.s FROM "dbrdf_StadiumOrArena_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_StadiumOrArena_delta_old";
        INSERT INTO "dbrdf_StadiumOrArena_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_StadiumOrArena_delta_new" t0;
        TRUNCATE TABLE "dbrdf_StadiumOrArena_delta_new";

        INSERT INTO "dbrdf_Arena"(s) SELECT DISTINCT t0.s FROM "dbrdf_Arena_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Arena_delta_old";
        INSERT INTO "dbrdf_Arena_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Arena_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Arena_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1813
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_headquarter_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_headquarter_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_headquarter" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_headquarter_delta_old" ON "dbrdf_headquarter_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_headquarter_delta_old" ON "dbrdf_headquarter_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_headquarter_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1814
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mass_delta_old3"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mass_delta_old3"(s, o) SELECT t0.s, t0.o FROM "dbrdf_mass3" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mass_delta_old3" ON "dbrdf_mass_delta_old3"(s, o); CREATE INDEX "IDX_1_dbrdf_mass_delta_old3" ON "dbrdf_mass_delta_old3"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mass_delta_new3"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1815
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_branchTo_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_branchTo_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_branchTo" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_branchTo_delta_old" ON "dbrdf_branchTo_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_branchTo_delta_old" ON "dbrdf_branchTo_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_branchTo_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1816
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_description_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_description_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_description" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_description_delta_old" ON "dbrdf_description_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_description_delta_old" ON "dbrdf_description_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_description_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1817
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_passengersPerDay_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_passengersPerDay_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_passengersPerDay" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_passengersPerDay_delta_old" ON "dbrdf_passengersPerDay_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_passengersPerDay_delta_old" ON "dbrdf_passengersPerDay_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_passengersPerDay_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1818
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_meaning_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_meaning_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_meaning" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_meaning_delta_old" ON "dbrdf_meaning_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_meaning_delta_old" ON "dbrdf_meaning_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_meaning_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1819
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_militaryUnit_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_militaryUnit_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_militaryUnit" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_militaryUnit_delta_old" ON "dbrdf_militaryUnit_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_militaryUnit_delta_old" ON "dbrdf_militaryUnit_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_militaryUnit_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1820
    ---- DEPENDS ON: 1819, 1801, 1596, 1541, 1223, 1159, 887, 868, 809, 492, 457, 70, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/MilitaryPerson>(?X) :- <http://dbpedia.org/ontology/war>(?X,?X1) .
    INSERT INTO "dbrdf_MilitaryPerson"(s) SELECT DISTINCT t0.s FROM "dbrdf_war" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_MilitaryPerson" 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_MilitaryPerson_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_MilitaryPerson_delta_old"(s) SELECT t0.s FROM "dbrdf_MilitaryPerson" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_MilitaryPerson_delta_old" ON "dbrdf_MilitaryPerson_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_MilitaryPerson_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/MilitaryPerson$delta_new>(?Y) :- <http://dbpedia.org/ontology/MilitaryPerson$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_MilitaryPerson_delta_new"(s) SELECT t1.o FROM "dbrdf_MilitaryPerson_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_MilitaryPerson" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_MilitaryPerson"(s) SELECT DISTINCT t0.s FROM "dbrdf_MilitaryPerson_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_MilitaryPerson_delta_old";
        INSERT INTO "dbrdf_MilitaryPerson_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_MilitaryPerson_delta_new" t0;
        TRUNCATE TABLE "dbrdf_MilitaryPerson_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1821
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1822
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_notableWine_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_notableWine_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_notableWine" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_notableWine_delta_old" ON "dbrdf_notableWine_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_notableWine_delta_old" ON "dbrdf_notableWine_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_notableWine_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1823
    ---- DEPENDS ON: 1822, 362, 13, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

    -- [Rule] <http://dbpedia.org/ontology/Grape>(?X) :- <http://dbpedia.org/ontology/wineRegion>(?X,?X1) .
    INSERT INTO "dbrdf_Grape"(s) SELECT DISTINCT t0.s FROM "dbrdf_wineRegion" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Grape" 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_Grape_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Grape_delta_old"(s) SELECT t0.s FROM "dbrdf_Grape" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Grape_delta_old" ON "dbrdf_Grape_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Grape_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/Grape$delta_new>(?Y) :- <http://dbpedia.org/ontology/Grape$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Grape_delta_new"(s) SELECT t1.o FROM "dbrdf_Grape_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Grape" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Grape"(s) SELECT DISTINCT t0.s FROM "dbrdf_Grape_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Grape_delta_old";
        INSERT INTO "dbrdf_Grape_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Grape_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Grape_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1824
    ---- DEPENDS ON: 1823, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/FloweringPlant>(?X) :- <http://dbpedia.org/ontology/Grape>(?X) .
    INSERT INTO "dbrdf_FloweringPlant"(s) SELECT t0.s FROM "dbrdf_Grape" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_FloweringPlant" 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_FloweringPlant_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_FloweringPlant_delta_old"(s) SELECT t0.s FROM "dbrdf_FloweringPlant" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_FloweringPlant_delta_old" ON "dbrdf_FloweringPlant_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_FloweringPlant_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/FloweringPlant$delta_new>(?Y) :- <http://dbpedia.org/ontology/FloweringPlant$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_FloweringPlant_delta_new"(s) SELECT t1.o FROM "dbrdf_FloweringPlant_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_FloweringPlant" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_FloweringPlant"(s) SELECT DISTINCT t0.s FROM "dbrdf_FloweringPlant_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_FloweringPlant_delta_old";
        INSERT INTO "dbrdf_FloweringPlant_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_FloweringPlant_delta_new" t0;
        TRUNCATE TABLE "dbrdf_FloweringPlant_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1825
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_secondDriver_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_secondDriver_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_secondDriver" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_secondDriver_delta_old" ON "dbrdf_secondDriver_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_secondDriver_delta_old" ON "dbrdf_secondDriver_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_secondDriver_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1826
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_floorArea0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_floorArea_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_floorArea_delta_old0";
        INSERT INTO "dbrdf_floorArea_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_floorArea_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_floorArea_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1827
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfLiveAlbums_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfLiveAlbums_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfLiveAlbums" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfLiveAlbums_delta_old" ON "dbrdf_numberOfLiveAlbums_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfLiveAlbums_delta_old" ON "dbrdf_numberOfLiveAlbums_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfLiveAlbums_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1828
    ---- DEPENDS ON: 1810, 1649, 1613, 1435, 1095, 922, 607, 596, 538, 533, 458, 391, 387, 212, 62, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [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/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/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;

    -- [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;

    -- 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 1829
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_chairman_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_chairman_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_chairman" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_chairman_delta_old" ON "dbrdf_chairman_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_chairman_delta_old" ON "dbrdf_chairman_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_chairman_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1830
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstFlight_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstFlight_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_firstFlight" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstFlight_delta_old" ON "dbrdf_firstFlight_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstFlight_delta_old" ON "dbrdf_firstFlight_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstFlight_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1831
    ---- DEPENDS ON: 1830, 1667, 1523, 1484, 1356, 1186, 1108, 1037, 819, 640, 608, 349, 285, 189, 166, 124, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [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/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/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_distance1" 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/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/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/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/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>(?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>(?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 1832
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sisterStation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sisterStation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_sisterStation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sisterStation_delta_old" ON "dbrdf_sisterStation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sisterStation_delta_old" ON "dbrdf_sisterStation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sisterStation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1833
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_notableWork_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_notableWork_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_notableWork" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_notableWork_delta_old" ON "dbrdf_notableWork_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_notableWork_delta_old" ON "dbrdf_notableWork_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_notableWork_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1834
    ---- DEPENDS ON: 1833, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Writer>(?X) :- <http://dbpedia.org/ontology/notableWork>(?X,?X1) .
    INSERT INTO "dbrdf_Writer"(s) SELECT DISTINCT t0.s FROM "dbrdf_notableWork" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Writer" 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_Writer_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Writer_delta_old"(s) SELECT t0.s FROM "dbrdf_Writer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Writer_delta_old" ON "dbrdf_Writer_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Writer_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/Writer$delta_new>(?Y) :- <http://dbpedia.org/ontology/Writer$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Writer_delta_new"(s) SELECT t1.o FROM "dbrdf_Writer_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Writer" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Writer"(s) SELECT DISTINCT t0.s FROM "dbrdf_Writer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Writer_delta_old";
        INSERT INTO "dbrdf_Writer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Writer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Writer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1835
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1836
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_plant_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_plant_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_plant" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_plant_delta_old" ON "dbrdf_plant_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_plant_delta_old" ON "dbrdf_plant_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_plant_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1837
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1838
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtJapan_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtJapan_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_winsAtJapan" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtJapan_delta_old" ON "dbrdf_winsAtJapan_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtJapan_delta_old" ON "dbrdf_winsAtJapan_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtJapan_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1839
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_largestCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_largestCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_largestCountry" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_largestCountry_delta_old" ON "dbrdf_largestCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_largestCountry_delta_old" ON "dbrdf_largestCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_largestCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1840
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_highestBuildingInYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_highestBuildingInYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_highestBuildingInYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_highestBuildingInYear_delta_old" ON "dbrdf_highestBuildingInYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_highestBuildingInYear_delta_old" ON "dbrdf_highestBuildingInYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_highestBuildingInYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1841
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_arrondissement_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_arrondissement_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_arrondissement" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_arrondissement_delta_old" ON "dbrdf_arrondissement_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_arrondissement_delta_old" ON "dbrdf_arrondissement_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_arrondissement_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1842
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ekatteCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ekatteCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_ekatteCode" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ekatteCode_delta_old" ON "dbrdf_ekatteCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ekatteCode_delta_old" ON "dbrdf_ekatteCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ekatteCode_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1843
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_storyEditor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_storyEditor_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_storyEditor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_storyEditor_delta_old" ON "dbrdf_storyEditor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_storyEditor_delta_old" ON "dbrdf_storyEditor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_storyEditor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1844
    ---- DEPENDS ON: 1843, 1773, 1530, 1509, 1503, 1386, 1241, 954, 727, 650, 524, 480, 228, 136, 37, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/TelevisionShow>(?X) :- <http://dbpedia.org/ontology/showJudge>(?X,?X1) .
    INSERT INTO "dbrdf_TelevisionShow"(s) SELECT DISTINCT t0.s FROM "dbrdf_showJudge" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_TelevisionShow" 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_TelevisionShow_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_TelevisionShow_delta_old"(s) SELECT t0.s FROM "dbrdf_TelevisionShow" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_TelevisionShow_delta_old" ON "dbrdf_TelevisionShow_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_TelevisionShow_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/TelevisionShow$delta_new>(?Y) :- <http://dbpedia.org/ontology/TelevisionShow$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_TelevisionShow_delta_new"(s) SELECT t1.o FROM "dbrdf_TelevisionShow_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_TelevisionShow" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_TelevisionShow"(s) SELECT DISTINCT t0.s FROM "dbrdf_TelevisionShow_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_TelevisionShow_delta_old";
        INSERT INTO "dbrdf_TelevisionShow_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_TelevisionShow_delta_new" t0;
        TRUNCATE TABLE "dbrdf_TelevisionShow_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1845
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1846
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_relatedMeanOfTransportation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_relatedMeanOfTransportation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_relatedMeanOfTransportation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_relatedMeanOfTransportation_delta_old" ON "dbrdf_relatedMeanOfTransportation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_relatedMeanOfTransportation_delta_old" ON "dbrdf_relatedMeanOfTransportation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_relatedMeanOfTransportation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1847
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_goyaAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_goyaAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_goyaAward" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_goyaAward_delta_old" ON "dbrdf_goyaAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_goyaAward_delta_old" ON "dbrdf_goyaAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_goyaAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1848
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_vein_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_vein_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_vein" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_vein_delta_old" ON "dbrdf_vein_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_vein_delta_old" ON "dbrdf_vein_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_vein_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1849
    ---- DEPENDS ON: 1848, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Vein>(?X1) :- <http://dbpedia.org/ontology/vein>(?X,?X1) .
    INSERT INTO "dbrdf_Vein"(s) SELECT DISTINCT t0.o FROM "dbrdf_vein" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Vein" 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_Vein_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Vein_delta_old"(s) SELECT t0.s FROM "dbrdf_Vein" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Vein_delta_old" ON "dbrdf_Vein_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Vein_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/Vein$delta_new>(?Y) :- <http://dbpedia.org/ontology/Vein$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Vein_delta_new"(s) SELECT t1.o FROM "dbrdf_Vein_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Vein" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Vein"(s) SELECT DISTINCT t0.s FROM "dbrdf_Vein_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Vein_delta_old";
        INSERT INTO "dbrdf_Vein_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Vein_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Vein_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1850
    ---- DEPENDS ON: 1848, 1815, 1405, 1204, 1119, 1049, 1002, 969, 849, 837, 815, 786, 743, 655, 874, 598, 594, 552, 545, 494, 459, 382, 850, 838, 243, 1849, 152, 1406, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/AnatomicalStructure>(?X) :- <http://dbpedia.org/ontology/artery>(?X,?X1) .
    INSERT INTO "dbrdf_AnatomicalStructure"(s) SELECT DISTINCT t0.s FROM "dbrdf_artery" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_AnatomicalStructure" 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_AnatomicalStructure_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_AnatomicalStructure_delta_old"(s) SELECT t0.s FROM "dbrdf_AnatomicalStructure" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_AnatomicalStructure_delta_old" ON "dbrdf_AnatomicalStructure_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_AnatomicalStructure_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/AnatomicalStructure$delta_new>(?Y) :- <http://dbpedia.org/ontology/AnatomicalStructure$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_AnatomicalStructure_delta_new"(s) SELECT t1.o FROM "dbrdf_AnatomicalStructure_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_AnatomicalStructure" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_AnatomicalStructure"(s) SELECT DISTINCT t0.s FROM "dbrdf_AnatomicalStructure_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_AnatomicalStructure_delta_old";
        INSERT INTO "dbrdf_AnatomicalStructure_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_AnatomicalStructure_delta_new" t0;
        TRUNCATE TABLE "dbrdf_AnatomicalStructure_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1851
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_functionEndDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_functionEndDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_functionEndDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_functionEndDate_delta_old" ON "dbrdf_functionEndDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_functionEndDate_delta_old" ON "dbrdf_functionEndDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_functionEndDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1852
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1853
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1854
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_goldenCalfAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_goldenCalfAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_goldenCalfAward" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_goldenCalfAward_delta_old" ON "dbrdf_goldenCalfAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_goldenCalfAward_delta_old" ON "dbrdf_goldenCalfAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_goldenCalfAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1855
    ---- DEPENDS ON: 1854, 1669, 1540, 1352, 1243, 981, 880, 444, 263, 187, 174, 1692, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Actor>(?X) :- <http://dbpedia.org/ontology/AdultActor>(?X) .
    INSERT INTO "dbrdf_Actor"(s) SELECT t0.s FROM "dbrdf_AdultActor" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Actor" 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_Actor_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Actor_delta_old"(s) SELECT t0.s FROM "dbrdf_Actor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Actor_delta_old" ON "dbrdf_Actor_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Actor_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/Actor$delta_new>(?Y) :- <http://dbpedia.org/ontology/Actor$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Actor_delta_new"(s) SELECT t1.o FROM "dbrdf_Actor_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Actor" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Actor"(s) SELECT DISTINCT t0.s FROM "dbrdf_Actor_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Actor_delta_old";
        INSERT INTO "dbrdf_Actor_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Actor_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Actor_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1856
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_majorShrine_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_majorShrine_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_majorShrine" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_majorShrine_delta_old" ON "dbrdf_majorShrine_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_majorShrine_delta_old" ON "dbrdf_majorShrine_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_majorShrine_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1857
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dynasty_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dynasty_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_dynasty" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dynasty_delta_old" ON "dbrdf_dynasty_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dynasty_delta_old" ON "dbrdf_dynasty_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dynasty_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1858
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstAirDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstAirDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_firstAirDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstAirDate_delta_old" ON "dbrdf_firstAirDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstAirDate_delta_old" ON "dbrdf_firstAirDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstAirDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1859
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1860
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_soocerLeagueRelegated_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_soocerLeagueRelegated_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_soocerLeagueRelegated" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_soocerLeagueRelegated_delta_old" ON "dbrdf_soocerLeagueRelegated_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_soocerLeagueRelegated_delta_old" ON "dbrdf_soocerLeagueRelegated_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_soocerLeagueRelegated_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1861
    ---- DEPENDS ON: 1860, 1064, 924, 434, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/SoccerLeagueSeason>(?X1) :- <http://dbpedia.org/ontology/soocerLeagueSeason>(?X,?X1) .
    INSERT INTO "dbrdf_SoccerLeagueSeason"(s) SELECT DISTINCT t0.o FROM "dbrdf_soocerLeagueSeason" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_SoccerLeagueSeason" 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_SoccerLeagueSeason_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SoccerLeagueSeason_delta_old"(s) SELECT t0.s FROM "dbrdf_SoccerLeagueSeason" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SoccerLeagueSeason_delta_old" ON "dbrdf_SoccerLeagueSeason_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SoccerLeagueSeason_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/SoccerLeagueSeason$delta_new>(?Y) :- <http://dbpedia.org/ontology/SoccerLeagueSeason$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_SoccerLeagueSeason_delta_new"(s) SELECT t1.o FROM "dbrdf_SoccerLeagueSeason_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_SoccerLeagueSeason" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_SoccerLeagueSeason"(s) SELECT DISTINCT t0.s FROM "dbrdf_SoccerLeagueSeason_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SoccerLeagueSeason_delta_old";
        INSERT INTO "dbrdf_SoccerLeagueSeason_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SoccerLeagueSeason_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SoccerLeagueSeason_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1862
    ---- DEPENDS ON: 1861, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/SoccerLeague>(?X) :- <http://dbpedia.org/ontology/SoccerLeagueSeason>(?X) .
    INSERT INTO "dbrdf_SoccerLeague"(s) SELECT t0.s FROM "dbrdf_SoccerLeagueSeason" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_SoccerLeague" 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_SoccerLeague_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SoccerLeague_delta_old"(s) SELECT t0.s FROM "dbrdf_SoccerLeague" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SoccerLeague_delta_old" ON "dbrdf_SoccerLeague_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SoccerLeague_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/SoccerLeague$delta_new>(?Y) :- <http://dbpedia.org/ontology/SoccerLeague$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_SoccerLeague_delta_new"(s) SELECT t1.o FROM "dbrdf_SoccerLeague_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_SoccerLeague" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_SoccerLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_SoccerLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SoccerLeague_delta_old";
        INSERT INTO "dbrdf_SoccerLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SoccerLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SoccerLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1863
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1864
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_musicBy_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_musicBy_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_musicBy" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_musicBy_delta_old" ON "dbrdf_musicBy_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_musicBy_delta_old" ON "dbrdf_musicBy_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_musicBy_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1865
    ---- DEPENDS ON: 1864, 1342, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- [Rule] <http://dbpedia.org/ontology/Musical>(?X) :- <http://dbpedia.org/ontology/musicBy>(?X,?X1) .
    INSERT INTO "dbrdf_Musical"(s) SELECT DISTINCT t0.s FROM "dbrdf_musicBy" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Musical" 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_Musical_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Musical_delta_old"(s) SELECT t0.s FROM "dbrdf_Musical" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Musical_delta_old" ON "dbrdf_Musical_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Musical_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/Musical$delta_new>(?Y) :- <http://dbpedia.org/ontology/Musical$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Musical_delta_new"(s) SELECT t1.o FROM "dbrdf_Musical_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Musical" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Musical"(s) SELECT DISTINCT t0.s FROM "dbrdf_Musical_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Musical_delta_old";
        INSERT INTO "dbrdf_Musical_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Musical_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Musical_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1866
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1867
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1868
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1869
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_saint_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_saint_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_saint" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_saint_delta_old" ON "dbrdf_saint_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_saint_delta_old" ON "dbrdf_saint_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_saint_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1870
    ---- DEPENDS ON: 1869, 1856, 1502, 1152, 1137, 1116, 890, 385, 351, 274, 154, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Saint>(?X) :- <http://dbpedia.org/ontology/feastDay>(?X,?X1) .
    INSERT INTO "dbrdf_Saint"(s) SELECT DISTINCT t0.s FROM "dbrdf_feastDay" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Saint" 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_Saint_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Saint_delta_old"(s) SELECT t0.s FROM "dbrdf_Saint" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Saint_delta_old" ON "dbrdf_Saint_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Saint_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/Saint$delta_new>(?Y) :- <http://dbpedia.org/ontology/Saint$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Saint_delta_new"(s) SELECT t1.o FROM "dbrdf_Saint_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Saint" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Saint"(s) SELECT DISTINCT t0.s FROM "dbrdf_Saint_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Saint_delta_old";
        INSERT INTO "dbrdf_Saint_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Saint_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Saint_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1871
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_acceleration0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_acceleration_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_acceleration_delta_old0";
        INSERT INTO "dbrdf_acceleration_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_acceleration_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_acceleration_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1872
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfIslands_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfIslands_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfIslands" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfIslands_delta_old" ON "dbrdf_numberOfIslands_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfIslands_delta_old" ON "dbrdf_numberOfIslands_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfIslands_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1873
    ---- DEPENDS ON: 1872, 1750, 1711, 1643, 1583, 1524, 1427, 1387, 1376, 1248, 1230, 1217, 1048, 1032, 836, 810, 805, 796, 776, 714, 587, 454, 360, 338, 308, 297, 279, 140, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Island>(?X) :- <http://dbpedia.org/ontology/governmentPlace>(?X,?X1) .
    INSERT INTO "dbrdf_Island"(s) SELECT DISTINCT t0.s FROM "dbrdf_governmentPlace" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Island" 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_Island_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Island_delta_old"(s) SELECT t0.s FROM "dbrdf_Island" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Island_delta_old" ON "dbrdf_Island_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Island_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/Island$delta_new>(?Y) :- <http://dbpedia.org/ontology/Island$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Island_delta_new"(s) SELECT t1.o FROM "dbrdf_Island_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Island" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Island"(s) SELECT DISTINCT t0.s FROM "dbrdf_Island_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Island_delta_old";
        INSERT INTO "dbrdf_Island_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Island_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Island_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1874
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1875
    ---- DEPENDS ON: 1874, 1654, 1529, 1520, 1335, 1007, 928, 787, 611, 509, 469, 215, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [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/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/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>(?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>(?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 1876
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_apparentMagnitude_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_apparentMagnitude_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_apparentMagnitude" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_apparentMagnitude_delta_old" ON "dbrdf_apparentMagnitude_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_apparentMagnitude_delta_old" ON "dbrdf_apparentMagnitude_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_apparentMagnitude_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1877
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_genomeDB_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_genomeDB_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_genomeDB" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_genomeDB_delta_old" ON "dbrdf_genomeDB_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_genomeDB_delta_old" ON "dbrdf_genomeDB_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_genomeDB_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1878
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_elo_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_elo_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_elo" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_elo_delta_old" ON "dbrdf_elo_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_elo_delta_old" ON "dbrdf_elo_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_elo_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1879
    ---- DEPENDS ON: 1878, 1166, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- [Rule] <http://dbpedia.org/ontology/ChessPlayer>(?X) :- <http://dbpedia.org/ontology/eloRecord>(?X,?X1) .
    INSERT INTO "dbrdf_ChessPlayer"(s) SELECT DISTINCT t0.s FROM "dbrdf_eloRecord" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_ChessPlayer" 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_ChessPlayer_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ChessPlayer_delta_old"(s) SELECT t0.s FROM "dbrdf_ChessPlayer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ChessPlayer_delta_old" ON "dbrdf_ChessPlayer_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ChessPlayer_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/ChessPlayer$delta_new>(?Y) :- <http://dbpedia.org/ontology/ChessPlayer$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_ChessPlayer_delta_new"(s) SELECT t1.o FROM "dbrdf_ChessPlayer_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_ChessPlayer" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_ChessPlayer"(s) SELECT DISTINCT t0.s FROM "dbrdf_ChessPlayer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_ChessPlayer_delta_old";
        INSERT INTO "dbrdf_ChessPlayer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_ChessPlayer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ChessPlayer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1880
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfLaunches_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfLaunches_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfLaunches" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfLaunches_delta_old" ON "dbrdf_numberOfLaunches_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfLaunches_delta_old" ON "dbrdf_numberOfLaunches_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfLaunches_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1881
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1882
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_watershed0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_watershed_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_watershed_delta_old0";
        INSERT INTO "dbrdf_watershed_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_watershed_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_watershed_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1883
    ---- DEPENDS ON: 1882, 1714, 1014, 1779, 668, 472, 260, 44, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Stream>(?X) :- <http://dbpedia.org/ontology/Stream/watershed>(?X,?X1) .
    INSERT INTO "dbrdf_Stream"(s) SELECT DISTINCT t0.s FROM "dbrdf_watershed" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Stream" 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_Stream_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Stream_delta_old"(s) SELECT t0.s FROM "dbrdf_Stream" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Stream_delta_old" ON "dbrdf_Stream_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Stream_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/Stream$delta_new>(?Y) :- <http://dbpedia.org/ontology/Stream$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Stream_delta_new"(s) SELECT t1.o FROM "dbrdf_Stream_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Stream" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Stream"(s) SELECT DISTINCT t0.s FROM "dbrdf_Stream_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Stream_delta_old";
        INSERT INTO "dbrdf_Stream_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Stream_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Stream_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1884
    ---- DEPENDS ON: 1650, 1661, 1883, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

    -- [Rule] <http://dbpedia.org/ontology/BodyOfWater>(?X) :- <http://dbpedia.org/ontology/Lake>(?X) .
    INSERT INTO "dbrdf_BodyOfWater0"(s) SELECT t0.s FROM "dbrdf_Lake" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_BodyOfWater0" 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_BodyOfWater_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_BodyOfWater_delta_old"(s) SELECT t0.s FROM "dbrdf_BodyOfWater" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_BodyOfWater_delta_old" ON "dbrdf_BodyOfWater_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_BodyOfWater_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_BodyOfWater_delta_old0"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_BodyOfWater_delta_old0"(s) SELECT t0.s FROM "dbrdf_BodyOfWater0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_BodyOfWater_delta_old0" ON "dbrdf_BodyOfWater_delta_old0"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_BodyOfWater_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/BodyOfWater$delta_new>(?X) :- <http://dbpedia.org/ontology/BodyOfWater$delta_old>(?X) .
        INSERT INTO "dbrdf_BodyOfWater_delta_new"(s) SELECT t0.s FROM "dbrdf_BodyOfWater_delta_old0" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_BodyOfWater" ex WHERE ex.s = t0.s);


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


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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_BodyOfWater"(s) SELECT DISTINCT t0.s FROM "dbrdf_BodyOfWater_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_BodyOfWater_delta_old";
        INSERT INTO "dbrdf_BodyOfWater_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_BodyOfWater_delta_new" t0;
        TRUNCATE TABLE "dbrdf_BodyOfWater_delta_new";

        INSERT INTO "dbrdf_BodyOfWater0"(s) SELECT DISTINCT t0.s FROM "dbrdf_BodyOfWater_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_BodyOfWater_delta_old0";
        INSERT INTO "dbrdf_BodyOfWater_delta_old0"(s) SELECT DISTINCT t0.s FROM "dbrdf_BodyOfWater_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_BodyOfWater_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1885
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1886
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dissolved_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dissolved_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_dissolved" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dissolved_delta_old" ON "dbrdf_dissolved_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dissolved_delta_old" ON "dbrdf_dissolved_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dissolved_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1887
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1888
    ---- DEPENDS ON: 1887, 1629, 1470, 1448, 1123, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [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>(?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/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;

    -- [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;

    -- 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 1889
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rankInFinalMedalCount_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rankInFinalMedalCount_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_rankInFinalMedalCount" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rankInFinalMedalCount_delta_old" ON "dbrdf_rankInFinalMedalCount_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rankInFinalMedalCount_delta_old" ON "dbrdf_rankInFinalMedalCount_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rankInFinalMedalCount_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1890
    ---- DEPENDS ON: 1889, 1602, 1588, 1359, 1227, 972, 923, 867, 591, 532, 374, 330, 276, 84, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [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>(?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>(?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/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/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/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/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/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/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;

    -- [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;

    -- 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 1891
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rector_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rector_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_rector" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rector_delta_old" ON "dbrdf_rector_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rector_delta_old" ON "dbrdf_rector_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rector_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1892
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sheading_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sheading_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_sheading" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sheading_delta_old" ON "dbrdf_sheading_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sheading_delta_old" ON "dbrdf_sheading_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sheading_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1893
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_onChromosome_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_onChromosome_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_onChromosome" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_onChromosome_delta_old" ON "dbrdf_onChromosome_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_onChromosome_delta_old" ON "dbrdf_onChromosome_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_onChromosome_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1894
    ---- DEPENDS ON: 1785, 1254, 1238, 1070, 993, 950, 937, 845, 467, 439, 247, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/YearInSpaceflight>(?X) :- <http://dbpedia.org/ontology/lastLaunch>(?X,?X1) .
    INSERT INTO "dbrdf_YearInSpaceflight"(s) SELECT DISTINCT t0.s FROM "dbrdf_lastLaunch" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_YearInSpaceflight" 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_YearInSpaceflight_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_YearInSpaceflight_delta_old"(s) SELECT t0.s FROM "dbrdf_YearInSpaceflight" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_YearInSpaceflight_delta_old" ON "dbrdf_YearInSpaceflight_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_YearInSpaceflight_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/YearInSpaceflight$delta_new>(?Y) :- <http://dbpedia.org/ontology/YearInSpaceflight$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_YearInSpaceflight_delta_new"(s) SELECT t1.o FROM "dbrdf_YearInSpaceflight_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_YearInSpaceflight" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_YearInSpaceflight"(s) SELECT DISTINCT t0.s FROM "dbrdf_YearInSpaceflight_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_YearInSpaceflight_delta_old";
        INSERT INTO "dbrdf_YearInSpaceflight_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_YearInSpaceflight_delta_new" t0;
        TRUNCATE TABLE "dbrdf_YearInSpaceflight_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1895
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1896
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1897
    ---- DEPENDS ON: 1896, 1737, 846, 310, 184, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/BaseballPlayer>(?X) :- <http://dbpedia.org/ontology/throwingSide>(?X,?X1) .
    INSERT INTO "dbrdf_BaseballPlayer"(s) SELECT DISTINCT t0.s FROM "dbrdf_throwingSide" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_BaseballPlayer" 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_BaseballPlayer_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_BaseballPlayer_delta_old"(s) SELECT t0.s FROM "dbrdf_BaseballPlayer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_BaseballPlayer_delta_old" ON "dbrdf_BaseballPlayer_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_BaseballPlayer_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/BaseballPlayer$delta_new>(?Y) :- <http://dbpedia.org/ontology/BaseballPlayer$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_BaseballPlayer_delta_new"(s) SELECT t1.o FROM "dbrdf_BaseballPlayer_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_BaseballPlayer" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_BaseballPlayer"(s) SELECT DISTINCT t0.s FROM "dbrdf_BaseballPlayer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_BaseballPlayer_delta_old";
        INSERT INTO "dbrdf_BaseballPlayer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_BaseballPlayer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_BaseballPlayer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1898
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1899
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mass_delta_old4"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mass_delta_old4"(s, o) SELECT t0.s, t0.o FROM "dbrdf_mass4" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mass_delta_old4" ON "dbrdf_mass_delta_old4"(s, o); CREATE INDEX "IDX_1_dbrdf_mass_delta_old4" ON "dbrdf_mass_delta_old4"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mass_delta_new4"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1900
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastSeason_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lastSeason_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lastSeason" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lastSeason_delta_old" ON "dbrdf_lastSeason_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lastSeason_delta_old" ON "dbrdf_lastSeason_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastSeason_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1901
    ---- DEPENDS ON: 1900, 1701, 1693, 1240, 1188, 1111, 1060, 983, 841, 823, 763, 498, 410, 246, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/FormulaOneRacer>(?X) :- <http://dbpedia.org/ontology/races>(?X,?X1) .
    INSERT INTO "dbrdf_FormulaOneRacer"(s) SELECT DISTINCT t0.s FROM "dbrdf_races" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_FormulaOneRacer" 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_FormulaOneRacer_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_FormulaOneRacer_delta_old"(s) SELECT t0.s FROM "dbrdf_FormulaOneRacer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_FormulaOneRacer_delta_old" ON "dbrdf_FormulaOneRacer_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_FormulaOneRacer_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/FormulaOneRacer$delta_new>(?Y) :- <http://dbpedia.org/ontology/FormulaOneRacer$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_FormulaOneRacer_delta_new"(s) SELECT t1.o FROM "dbrdf_FormulaOneRacer_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_FormulaOneRacer" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_FormulaOneRacer"(s) SELECT DISTINCT t0.s FROM "dbrdf_FormulaOneRacer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_FormulaOneRacer_delta_old";
        INSERT INTO "dbrdf_FormulaOneRacer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_FormulaOneRacer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_FormulaOneRacer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1902
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1903
    ---- DEPENDS ON: 1902, 1836, 1802, 1578, 1569, 1252, 1824, 612, 64, 2, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Plant"(s) SELECT DISTINCT t0.s FROM "dbrdf_Plant_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Plant_delta_old";
        INSERT INTO "dbrdf_Plant_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Plant_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Plant_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1904
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1905
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_meltingPoint_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_meltingPoint_delta_old1"(s, o) SELECT t0.s, t0.o FROM "dbrdf_meltingPoint1" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_meltingPoint_delta_old1" ON "dbrdf_meltingPoint_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_meltingPoint_delta_old1" ON "dbrdf_meltingPoint_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_meltingPoint_delta_new1"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1906
    ---- DEPENDS ON: 1905, 1390, 176, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Drug_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Drug_delta_old"(s) SELECT t0.s FROM "dbrdf_Drug" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Drug_delta_old" ON "dbrdf_Drug_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Drug_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1907
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfBombs_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfBombs_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfBombs" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfBombs_delta_old" ON "dbrdf_numberOfBombs_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfBombs_delta_old" ON "dbrdf_numberOfBombs_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfBombs_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1908
    ---- DEPENDS ON: 1451, 712, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- [Rule] <http://dbpedia.org/ontology/Beverage>(?X) :- <http://dbpedia.org/ontology/discontinued>(?X,?X1) .
    INSERT INTO "dbrdf_Beverage"(s) SELECT DISTINCT t0.s FROM "dbrdf_discontinued" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Beverage" 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_Beverage_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Beverage_delta_old"(s) SELECT t0.s FROM "dbrdf_Beverage" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Beverage_delta_old" ON "dbrdf_Beverage_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Beverage_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/Beverage$delta_new>(?Y) :- <http://dbpedia.org/ontology/Beverage$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Beverage_delta_new"(s) SELECT t1.o FROM "dbrdf_Beverage_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Beverage" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Beverage"(s) SELECT DISTINCT t0.s FROM "dbrdf_Beverage_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Beverage_delta_old";
        INSERT INTO "dbrdf_Beverage_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Beverage_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Beverage_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1909
    ---- DEPENDS ON: 1908, 1724, 1486, 744, 422, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Food>(?X) :- <http://dbpedia.org/ontology/ingredient>(?X,?X1) .
    INSERT INTO "dbrdf_Food"(s) SELECT DISTINCT t0.s FROM "dbrdf_ingredient" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Food" 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_Food_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Food_delta_old"(s) SELECT t0.s FROM "dbrdf_Food" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Food_delta_old" ON "dbrdf_Food_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Food_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/Food$delta_new>(?Y) :- <http://dbpedia.org/ontology/Food$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Food_delta_new"(s) SELECT t1.o FROM "dbrdf_Food_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Food" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Food"(s) SELECT DISTINCT t0.s FROM "dbrdf_Food_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Food_delta_old";
        INSERT INTO "dbrdf_Food_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Food_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Food_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1910
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_emmyAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_emmyAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_emmyAward" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_emmyAward_delta_old" ON "dbrdf_emmyAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_emmyAward_delta_old" ON "dbrdf_emmyAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_emmyAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1911
    ---- DEPENDS ON: 1910, 1854, 1847, 1669, 1659, 1540, 1515, 1434, 1381, 1352, 1328, 1323, 1251, 1243, 1057, 981, 976, 912, 781, 628, 588, 371, 284, 263, 187, 174, 129, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Award>(?X1) :- <http://dbpedia.org/ontology/naacpImageAward>(?X,?X1) .
    INSERT INTO "dbrdf_Award"(s) SELECT DISTINCT t0.o FROM "dbrdf_naacpImageAward" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Award" 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_Award_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Award_delta_old"(s) SELECT t0.s FROM "dbrdf_Award" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Award_delta_old" ON "dbrdf_Award_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Award_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/Award$delta_new>(?Y) :- <http://dbpedia.org/ontology/Award$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Award_delta_new"(s) SELECT t1.o FROM "dbrdf_Award_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Award" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Award"(s) SELECT DISTINCT t0.s FROM "dbrdf_Award_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Award_delta_old";
        INSERT INTO "dbrdf_Award_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Award_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Award_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1912
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_MotorcycleRacingLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_MotorcycleRacingLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_MotorcycleRacingLeague_delta_old";
        INSERT INTO "dbrdf_MotorcycleRacingLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_MotorcycleRacingLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_MotorcycleRacingLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1913
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1914
    ---- DEPENDS ON: 1913, 1871, 0, 1601, 1582, 1479, 1372, 1329, 1303, 1244, 1224, 1009, 855, 778, 715, 622, 550, 528, 488, 420, 313, 306, 286, 244, 135, 58, 49, 19, 18, 17
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/AutomobileEngine>(?X) :- <http://dbpedia.org/ontology/oilSystem>(?X,?X1) .
    INSERT INTO "dbrdf_AutomobileEngine"(s) SELECT DISTINCT t0.s FROM "dbrdf_oilSystem" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_AutomobileEngine" 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_AutomobileEngine_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_AutomobileEngine_delta_old"(s) SELECT t0.s FROM "dbrdf_AutomobileEngine" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_AutomobileEngine_delta_old" ON "dbrdf_AutomobileEngine_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_AutomobileEngine_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/AutomobileEngine$delta_new>(?Y) :- <http://dbpedia.org/ontology/AutomobileEngine$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_AutomobileEngine_delta_new"(s) SELECT t1.o FROM "dbrdf_AutomobileEngine_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_AutomobileEngine" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_AutomobileEngine"(s) SELECT DISTINCT t0.s FROM "dbrdf_AutomobileEngine_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_AutomobileEngine_delta_old";
        INSERT INTO "dbrdf_AutomobileEngine_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_AutomobileEngine_delta_new" t0;
        TRUNCATE TABLE "dbrdf_AutomobileEngine_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1915
    ---- DEPENDS ON: 1914, 1656, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- [Rule] <http://dbpedia.org/ontology/Device>(?X) :- <http://dbpedia.org/ontology/Weapon>(?X) .
    INSERT INTO "dbrdf_Device"(s) SELECT t0.s FROM "dbrdf_Weapon" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Device" 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_Device_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Device_delta_old"(s) SELECT t0.s FROM "dbrdf_Device" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Device_delta_old" ON "dbrdf_Device_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Device_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/Device$delta_new>(?Y) :- <http://dbpedia.org/ontology/Device$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Device_delta_new"(s) SELECT t1.o FROM "dbrdf_Device_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Device" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Device"(s) SELECT DISTINCT t0.s FROM "dbrdf_Device_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Device_delta_old";
        INSERT INTO "dbrdf_Device_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Device_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Device_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1916
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_functionStartDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_functionStartDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_functionStartDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_functionStartDate_delta_old" ON "dbrdf_functionStartDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_functionStartDate_delta_old" ON "dbrdf_functionStartDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_functionStartDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1917
    ---- DEPENDS ON: 1876, 1809, 1803, 1600, 1492, 1465, 1399, 1226, 1181, 1072, 915, 881, 789, 738, 699, 687, 656, 417, 408, 363, 324, 304, 280, 241, 232, 226, 63, 45, 38, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    -- [Rule] <http://dbpedia.org/ontology/Planet>(?X) :- <http://dbpedia.org/ontology/rotationPeriod>(?X,?X1) .
    INSERT INTO "dbrdf_Planet"(s) SELECT DISTINCT t0.s FROM "dbrdf_rotationPeriod" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Planet" 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_Planet_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Planet_delta_old"(s) SELECT t0.s FROM "dbrdf_Planet" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Planet_delta_old" ON "dbrdf_Planet_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Planet_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/Planet$delta_new>(?Y) :- <http://dbpedia.org/ontology/Planet$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Planet_delta_new"(s) SELECT t1.o FROM "dbrdf_Planet_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Planet" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Planet"(s) SELECT DISTINCT t0.s FROM "dbrdf_Planet_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Planet_delta_old";
        INSERT INTO "dbrdf_Planet_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Planet_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Planet_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1918
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1919
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_totalCargo_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_totalCargo_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_totalCargo" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_totalCargo_delta_old" ON "dbrdf_totalCargo_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_totalCargo_delta_old" ON "dbrdf_totalCargo_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_totalCargo_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1920
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_photographer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_photographer_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_photographer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
