.net - dataadapter.fill ejemplo

¿Por qué OracleDataAdapter.Fill() es muy lento?

Question

Estoy utilizando una consulta bastante compleja para recuperar algunos datos de una de nuestras bases de datos de facturación.

Estoy llegando a un problema donde la consulta parece completarse bastante rápido cuando se ejecuta con SQL Developer, pero parece que nunca termina cuando se utiliza el método OracleDataAdapter.Fill() .

Solo intento leer cerca de 1000 filas y la consulta finaliza en SQL Developer en unos 20 segundos.

¿Qué podría estar causando tales diferencias drásticas en el rendimiento? Tengo muchas otras consultas que se ejecutan rápidamente con la misma función.

Aquí está el código que estoy usando para ejecutar la consulta:

using Oracle.DataAccess.Client;

...

public DataTable ExecuteExternalQuery(string connectionString, string providerName, string queryText)
{
    DbConnection connection = null;
    DbCommand selectCommand = null;
    DbDataAdapter adapter = null;

    switch (providerName)
    {
        case "System.Data.OracleClient":
        case "Oracle.DataAccess.Client":
            connection = new OracleConnection(connectionString);
            selectCommand = connection.CreateCommand();
            adapter = new OracleDataAdapter((OracleCommand)selectCommand);
            break;
        ...
    }

    DataTable table = null;
    try
    {
        connection.Open();

        selectCommand.CommandText = queryText;
        selectCommand.CommandTimeout = 300000;
        selectCommand.CommandType = CommandType.Text;

        table = new DataTable("result");
        table.Locale = CultureInfo.CurrentCulture;
        adapter.Fill(table);
    }
    finally
    {
        adapter.Dispose();

        if (connection.State != ConnectionState.Closed)
        {
            connection.Close();
        }
    }

    return table;
}

Y aquí está el resumen general del SQL que estoy usando:

with
  trouble_calls as
  (
    select
      work_order_number,
      account_number,
      date_entered
    from
      work_orders
    where
      date_entered >= sysdate - (15 + 31)  -- Use the index to limit the number of rows scanned
     and
      wo_status not in (''Cancelled'')
     and
      wo_type = ''Trouble Call''
  )
select
  account_number,
  work_order_number,
  date_entered
from
  trouble_calls wo
where
  wo.icoms_date >= sysdate - 15
 and
  (
    select
      count(*)
    from
      trouble_calls repeat
    where
      wo.account_number = repeat.account_number
     and
      wo.work_order_number <> repeat.work_order_number
     and
      wo.date_entered - repeat.date_entered between 0 and 30
  ) >= 1

Answer 1

Creo que la cultura y la fecha que devuelve su consulta de Oracle son diferentes y es ahí donde la aplicación tarda mucho tiempo en analizar.

Answer 2

Se conocen diferencias de rendimiento entre el uso del proveedor de datos de Microsoft para Oracle y el proveedor de datos Oracle nativo.

¿Has probado ambos?

¿Qué estás tratando de lograr con esta consulta? Olvídate de cosas técnicas, solo el objetivo de todo. Tal vez hay una melodía posible para su consulta.

¿Has probado con un generador de perfiles para ver dónde se atasca?

Answer 3

Este código me ayudó, pruébalo:

using (OracleConnection conn = new OracleConnection())
{
     OracleCommand comm = new OracleCommand();
     comm.Connection = conn;
     comm.FetchSize = comm.FetchSize * 16;
     comm.CommandText = "select * from some_table";

     try
     {
          conn.Open();
          OracleDataAdapter adap = new OracleDataAdapter(comm);
          System.Data.DataTable dt = new System.Data.DataTable();
          adap.Fill(dt);
     }
     finally
     {
          conn.Close();
     }
}

El trik está en línea (prueba valores de 8 a 64 para encontrar lo mejor para tu caso):

comm.FetchSize = comm.FetchSize * 16;

ACTUALIZAR:

Aquí hay un código mejorado:

OracleConnection myConnection = new OracleConnection(myConnectionString);
OracleCommand myCommand = new OracleCommand(mySelectQuery, myConnection);
myConnection.Open();
using (OracleDataReader reader = myCommand.ExecuteReader(CommandBehavior.CloseConnection))
{
    // here goes the trick
    // lets get 1000 rows on each round trip
    reader.FetchSize = reader.RowSize * 1000;

    while (reader.Read())
    {
        // reads the records normally
    }
}// close and dispose stuff here

De aquí