paginação de dados em SQL Server CE (Compact Edition)

Question

Eu estou escrevendo um aplicativo destop WPF, e gostaria de usar o SQL Server CE como um backend. Eu estou tentando chegar a uma boa maneira de fazer paginação de dados eficiente. Em SQL Server Express, eu posso fazer algo como isto:

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    

Existe alguma coisa comparável em SQL Server CE? Eu não estou completamente certo o que é e não é suportado. Eu quero retornar apenas 10 linhas de cada vez a partir do banco de dados, e não ter que puxar para trás todos os dados e, em seguida, filtrá-la para baixo para exibir para o usuário, uma vez que é muito mais lento. Obrigado.

Answer 1

Honestamente, provavelmente a coisa mais rápida de fazer é usar um SqlCeDataReader e chamada .read () 10 vezes. Então, quando o usuário move para a próxima página, você já está apontando para o resultado 11, e pode ler mais 10. Se você precisa ir para trás, você pode armazenar em cache os resultados ou mudar para um SqlCeResultSet que suporta que procuram .

Além disso, SqlCeDataReader / Resultado é, a partir da experiência, a maneira mais rápida absoluta para interagir com o banco de dados no ambiente de trabalho. Pode ser, literalmente, 100 vezes mais rápido do que usar DataSets / DataAdapters.

Answer 2

No caso de que alguém atinge desta página procurando a resposta ... Eu vim através deste post: Suporte para paginação consultas no 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 isso ajude

Answer 3

Eu também estou trabalhando atualmente em um aplicativo WPF que usa SQL Server CE como o mecanismo de persistência. Temos vários (40+) mesas e alguns deles são muito grandes (50k registros, pelo menos é grande para os meus padrões).

Meu conselho sobre os dados paging diretamente no SQL CE é esta: evitá-lo se você pode! Eu tenho usado a abordagem descrita por Bob King, e, pelo menos para mim resultou em código muito feio, um pesadelo de manutenção real.

A menos que você vai precisar para página ao longo de dezenas de milhares de registros, acredito que a melhor abordagem é a carregá-los todos usando SqlCeDataReader em uma coleção de classes personalizadas e, em seguida, sobre a coleção na memória. Eu encontrei esta abordagem seja mais ágil do que a consulta SQL execução re-a cada vez, mesmo com o cache. O que aconteceu é que no meu caso as consultas eram bastante complexo, e desempenho SqlCeDataReader era bom o suficiente para que o acerto de desempenho foi quase imperceptível. Não há necessidade de apontar que, após a primeira carga de lote, cada mudança de página acontece quase instantaneamente, porque tudo é mantido na memória.

A opinião geral dos meus usuários foram que ele está ok para esperar um pouco mais para os primeiros resultados a aparecer, se isso vai levar a mais rápida paginação depois. E usando LINQ, paginação é tão fácil como chamar Skip e Take métodos. Eu tenho implementado essa lógica dentro de um Pager classe, tornando-se muito seco e agradável.

Answer 4

Existem algumas maneiras, mas a forma mais simplista seria como o seguinte:

Assumindo

1. Page Size = 10
2. Página = 2

Em seguida

1. Primeiro TOP = PageSize (10)
2. Em segundo lugar 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

Eu fiz implementar paginação personalizada para datagrid usando SQL CE. Eu implementei método de usar top na instrução select e pular registros usando subconsulta como discutido na resposta acima. Mas ele funciona bem com pequena quantidade de dados. Como os registros crescer em mil a metodologia acima torna-se menos útil e torna-se lenta no desempenho.

Eu resolvi problema de desempenho pobre usando minha própria técnica. O que eu fiz é i id loja de primeiro e último registro em cada página em variáveis.

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

e

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

Eu inicializar essas variáveis ??após a grade é binded para cada página.

Se o usuário clicar no próximo botão i buscar superior (Pagsize) registros de maior banco de dados do que LastRecord Se o usuário clicar no botão anterior i buscar registros superior (PageSize) do banco de dados a menos de FirstRecord. Também eu encomendar por id desc neste caso. E reordenar tabela de dados usando dataview para asc antes ligação a datagrid.

Ele fez o meu paginação mais eficiente. Embora eu tive que colocar algum esforço extra para a inserção e eliminação dos casos de registros. Mas eu era capaz de lidar com isso.