Need help optimizing a merge query

Question

Hi all, I hope someone can give me some assistance with this. I don't have a lot of experience with Oracle, so any help would be greatly appreciated. I have a MERGE query that I need to optimize as much as possible. I will give as much information as I can in this post.
Here is the actual query:
      MERGE INTO quick_scene_lookup qsl
      USING (
        SELECT scene.*,
          CASE
            WHEN scene.data_category LIKE 'NOM%'
              THEN 'NOM'
            WHEN scene.data_category LIKE 'ENG%'
              THEN 'ENG'
            WHEN scene.data_category LIKE 'VAL%'
              THEN 'VAL'
            ELSE scene.data_category
          END scn_data_category,
          CASE
            WHEN scene.data_category_original LIKE 'NOM%'
              THEN 'NOM'
            WHEN scene.data_category_original LIKE 'ENG%'
              THEN 'ENG'
            WHEN scene.data_category_original LIKE 'VAL%'
              THEN 'VAL'
            ELSE scene.data_category_original
          END data_category_orig,
          CASE
            WHEN scene.full_partial_scene LIKE 'F%'
              THEN 'F'
            WHEN scene.full_partial_scene LIKE 'P%'
              THEN 'P'
            ELSE scene.full_partial_scene
          END scn_full_partial_scene,
          CASE
            WHEN scene.date_entered_lam IS NULL
                OR scene.deleted = 1
              THEN 0
            ELSE 1
          END in_lam,
          CASE
            WHEN scene.in_uis LIKE 'Y%'
              THEN 1
            ELSE 0
          END scn_in_uis,
          CASE
            WHEN scene.data_category LIKE 'NOM%'
                AND scene.full_partial_scene LIKE 'F%'
              THEN 1
            ELSE 0
          END monitor,
          CASE
            WHEN scene.date_updated_lam IS NOT NULL
                AND scene.satellite_sensor_key = 8 -- L7 ETM
              THEN
                CASE
                  WHEN intv.match_in_tolerance = 'Y'
                      OR intv.match_in_tolerance = 'N'
                    THEN 0
                  ELSE 1
                END
             ELSE 0
          END lam_orphan,
          sat.satellite,
          sat.sensor_id,
          station.station_id,
          intv.match_in_tolerance,
          wrs.wrs_path,
          wrs.wrs_row,
          TO_DATE(SUBSTR(scene.scene_start_time, 0, 17),
              'YYYY:DDD:HH24:MI:SS') scn_scene_start_time,
          CASE
            WHEN qsl.date_downlinked IS NOT NULL
                AND scene.date_standing_request IS NOT NULL
              THEN (qsl.date_downlinked - scene.date_standing_request) * 1440
            ELSE NULL
          END dd_downlinked_marketable
        FROM all_scenes scene
        INNER JOIN lu_satellite sat
          ON (scene.satellite_sensor_key = sat.satellite_sensor_key)
        INNER JOIN ground_stations station
          ON (scene.station_key = station.station_key)
        INNER JOIN all_intervals intv
          ON (scene.landsat_interval_id = intv.landsat_interval_id)
        INNER JOIN worldwide_reference_system wrs
          ON (scene.wrs_key = wrs.wrs_key)
        LEFT OUTER JOIN quick_scene_lookup qsl
          ON (scene.landsat_scene_id = qsl.landsat_scene_id)
        WHERE (scene.job_sequence_key IN (
          SELECT job_sequence_key FROM jobs_subscript_execution_fact
          WHERE job_key = 109)
        OR qsl.landsat_scene_id IS NULL)
        AND scene.scene_version = (
          SELECT MAX(scene_version) FROM all_scenes
          WHERE SUBSTR(landsat_scene_id, 1, 19) =
            SUBSTR(scene.landsat_scene_id, 1, 19))) scenes
      ON (qsl.landsat_scene_id = scenes.landsat_scene_id
        OR (qsl.satellite = scenes.satellite
          AND qsl.station_id = scenes.station_id
          AND qsl.wrs_path = scenes.wrs_path
          AND qsl.wrs_row = scenes.wrs_row
          AND TRUNC(qsl.date_acquired) = TRUNC(scenes.date_acquired)
          AND SUBSTR(qsl.sensor_id, 1, 3) = SUBSTR(scenes.sensor_id, 1, 3)))
      WHEN MATCHED THEN
      UPDATE SET
        data_category = scenes.scn_data_category,
        data_category_original = scenes.data_category_orig,
        date_acquired = scenes.date_acquired,
        date_entered = scenes.date_entered,
        date_standing_request = scenes.date_standing_request,
        date_updated = scenes.date_updated,
        dd_downlinked_marketable = scenes.dd_downlinked_marketable,
        full_partial_scene = scenes.scn_full_partial_scene,
        in_lam = scenes.in_lam,
        in_uis = scenes.scn_in_uis,
        lam_orphan = scenes.lam_orphan,
        monitor = scenes.monitor,
        satellite = scenes.satellite,
        scene_start_time_date = scenes.scn_scene_start_time,
        sensor_id = scenes.sensor_id,
        station_id = scenes.station_id,
        wrs_path = scenes.wrs_path,
        wrs_row = scenes.wrs_row,
        cloud_cover = scenes.cloud_cover
      WHEN NOT MATCHED THEN INSERT(
        qsl_scene_id,
        data_category,
        data_category_original,
        date_acquired,
        date_entered,
        date_standing_request,
        date_updated,
        full_partial_scene,
        in_lam,
        in_moc,
        in_uis,
        lam_orphan,
        landsat_interval_id,
        landsat_scene_id,
        monitor,
        satellite,
        scene_start_time_date,
        sensor_id,
        station_id,
        wrs_path,
        wrs_row,
        cloud_cover)
      VALUES(
        seq_qsl_scene_id.nextval,
        scenes.scn_data_category,
        scenes.data_category_orig,
        scenes.date_acquired,
        scenes.date_entered,
        scenes.date_standing_request,
        scenes.date_updated,
        scenes.scn_full_partial_scene,
        scenes.in_lam,
        0,     -- in_moc will always be 0 for archive inserts
        scenes.scn_in_uis,
        scenes.lam_orphan,
        scenes.landsat_interval_id,
        scenes.landsat_scene_id,
        scenes.monitor,
        scenes.satellite,
        scenes.scn_scene_start_time,
        scenes.sensor_id,
        scenes.station_id,
        scenes.wrs_path,
        scenes.wrs_row,
        scenes.cloud_cover)
    LOG ERRORS INTO ingest_errors('Intervals error')
      REJECT LIMIT 500;All of the columns used in the joins have indexes. Also, all columns referenced in the WHERE clause also have indexes. I have function based indexes on the two columns that are using a function.
The cost from the explain plan is at 14 million, and this query takes far too long to run. I can post the explain plan if anybody wants it. We are running Oracle 10.2g, and are a data warehouse. Any help I can get on this would be greatly appreciated, I and my dba's are unable to come up with any more ideas. Thanks in advance.

Answer 1

Well, just in case this might help someone else out, I was able to resolve my issue with the code. It turns out that in the secondary condition of the ON clause for the merge, I had columns that were also being updated. By removing the those columns from the UPDATE clause. It dropped my cost down to 456,000. I was further able to reduce the cost of the query by removing the primary conditional completely. I am a C++ programmer and was counting on a short-circuit OR to speed up the process. Anyway, my cost is now down to 215,000, and all is good here.
Thanks.