Paginación de datos en SQL Server CE (Compact Edition)

Question

Estoy escribiendo una aplicación wpf destop, y me gustaría utilizar SQL Server CE como back-end. Estoy tratando de encontrar una buena manera de hacer una paginación de datos eficiente. En SQL Server Express, puedo hacer algo como esto:

Select ID, FirstName, LastName
From (SELECT  ROW_NUMBER() OVER (ORDER BY ID)
 AS Row, ID, FirstName, LastName
 From TestTable                             
) 
WHERE  Row > 1 AND Row <= 10    

¿Hay algo comparable en SQL Server CE? No estoy completamente seguro de qué es y qué no es compatible. Solo quiero devolver 10 filas a la vez desde la base de datos, y no tener que retirar todos los datos y luego filtrarlos para mostrarlos al usuario, ya que eso es mucho más lento. Gracias.

Answer 1

Honestamente, probablemente lo más rápido es usar un SqlCeDataReader y llame a .Read () 10 veces. Luego, cuando el usuario pasa a la página siguiente, ya está señalando el undécimo resultado y puede leer 10 más. Si necesita retroceder, puede guardar en caché sus resultados o cambiar a un SqlCeResultSet que admite buscando .

Además, SqlCeDataReader / Result es, por experiencia, la forma más rápida de interactuar con la base de datos en el escritorio. Puede ser literalmente 100 veces más rápido que usar DataSets / DataAdapters.

Answer 2

En el caso de que alguien llegue a esta página buscando la respuesta ... Me encontré con esta publicación: Soporte para consultas de paginación en SQL Server CE 4.0

http://beyondrelational.com/blogs/jacob/archive/2010/07/13/support-for-paging-queries-in-sql-server-ce-4-0.aspx

Espero que esto ayude

Answer 3

También estoy trabajando actualmente en una aplicación WPF que utiliza SQL Server CE como mecanismo de persistencia. Tenemos varias (40+) tablas y algunas de ellas son bastante grandes (50k registros, al menos eso es grande para mis estándares).

Mi consejo sobre la paginación de datos directamente en SQL CE es este: ¡evítelo si puede! He utilizado el enfoque descrito por Bob King, y al menos para mí resultó en un código muy feo, una verdadera pesadilla de mantenimiento.

A menos que necesite buscar en decenas de miles de registros, creo que el mejor enfoque es cargarlos todos usando SqlCeDataReader en una colección de clases personalizadas y luego paginar sobre la colección en la memoria. Este enfoque me pareció más receptivo que volver a ejecutar la consulta SQL cada vez, incluso con el almacenamiento en caché. Lo que sucedió es que en mi caso las consultas eran bastante complejas, y el rendimiento de SqlCeDataReader fue lo suficientemente bueno como para que el impacto en el rendimiento fuera casi imperceptible. No es necesario señalar que, después de la primera carga por lotes, cada cambio de página ocurre casi instantáneamente porque todo se guarda en la memoria.

La opinión general de mis usuarios era que está bien esperar un poco más para que aparezcan los primeros resultados, si eso va a conducir a una búsqueda más rápida después. Y utilizando LINQ, la búsqueda es tan fácil como llamar a los métodos Saltar y Tomar. He implementado esta lógica dentro de un Pager & Lt; T & Gt; clase, haciéndolo muy SECO y agradable.

Answer 4

Hay algunas formas, pero la forma más simplista sería la siguiente:

Asumiendo

1. Tamaño de página = 10
2. Página = 2

Entonces

1. First TOP = PageSize (10)
2. Second TOP = PageSize * Page (20)

SELECT
 [Page].[ID],
 [Page].[FirstName],
 [Page].[LastName]
FROM
(
SELECT TOP (10)
 [FirstRows].[ID],
 [FirstRows].[FirstName],
 [FirstRows].[LastName]
FROM
 (
 SELECT TOP (20)
  [TestTable].[ID],
  [TestTable].[FirstName],
  [TestTable].[LastName]
 FROM
  [TestTable]
 ORDER BY
  [TestTable].[ID] ASC
 ) AS [FirstRows]
ORDER BY 
 [FirstRows].[ID] DESC
) AS [Page]
ORDER BY
  [Page].[ID] ASC

Answer 5

Implementé una paginación personalizada para la cuadrícula de datos usando SQL CE. Implementé el método de usar top en la instrucción select y omitir registros usando subconsulta como se discutió en la respuesta anterior. Pero funciona bien con una pequeña cantidad de datos. A medida que los registros crecen en miles, la metodología anterior se vuelve menos útil y se vuelve lenta en el rendimiento.

Resolví un problema de bajo rendimiento utilizando mi propia técnica. Lo que hice fue almacenar la identificación del primer y último registro en cada página en variables.

dim firstRecord=dt.rows(0)("id")

y

dim lastRecord=dt.Rows(dt.rows.count-1)("id")

Inicializo estas variables después de que la cuadrícula está ligada para cada página.

Si el usuario hace clic en el botón Siguiente, obtengo los registros superiores (Pagsize) de la base de datos mayores que lastRecord  Si el usuario hace clic en el botón anterior, obtengo los registros superiores (Tamaño de página) de la base de datos menos que firstRecord. También ordeno por Id desc en este caso. Y reordene la tabla de datos usando dataview a asc antes de enlazar a datagrid.

Hizo que mi búsqueda fuera más eficiente. Aunque tuve que poner un esfuerzo extra para insertar y eliminar casos de registros. Pero pude manejar eso.