Tipos de cursores
Os cursores do Microsoft SQL Server Compact 3.5 são semelhantes aos cursores usados no SQL Server. As diferenças estão documentadas nesta seção. Para uma explicação completa sobre cursores de banco de dados, consulte os Manuais Online do SQL Server.
O SQL Server Compact 3.5 oferece suporte aos seguintes tipos de cursores:
Tabela base
Estático
Somente avanço
Somente avanço/somente leitura
Controlado por conjunto de chaves
Cursores de tabela base
Os cursores de tabela base são os cursores disponíveis com o menor nível. Esses cursores funcionam diretamente no mecanismo de armazenamento e são os tipos de cursores com suporte mais rápidos. Os cursores de tabela base podem ser rolar facilmente para frente e para trás e podem ser atualizados.
Você também pode abrir um cursor diretamente em um índice. Os índices têm suporte para ordenar as linhas em uma tabela, permitindo a busca em determinados valores e restringindo as linhas com base em um intervalo de valores dentro de um índice.
Os cursores de tabela base têm associação dinâmica. Isso significa que dois cursores abertos na mesma tabela podem ver imediatamente as inserções, exclusões e alterações nos dados, assumindo que ambos estejam no mesmo escopo da transação. Como você pode atualizar os cursores de tabela base, um cliente pode usar esse tipo de cursor para fazer alterações nos dados subjacentes.
Os cursores de tabela base não podem representar o resultado de uma consulta. Os resultados de consultas, como SELECT * FROM tablename, não são retornados por um cursor de tabela base. Em vez disso, um dos cursores do resultado da consulta com suporte é usado.
A seguir, um exemplo de como obter um cursor de tabela base usando ADO .NET:
//Base Table Cursor
cmd.CommandText = "tablename";
cmd.CommandType = CommandType.TableDirect;
SqlCeResultSet rs = cmd.ExecuteResultSet(ResultSetOptions.Scrollable | ResultSetOptions.Updatable);
A seguir, um exemplo de como obter um cursor de índice usando ADO .NET:
cmd.CommandText = "tablename";
cmd.IndexName = "indexname";
cmd.CommandType = CommandType.TableDirect;
SqlCeResultSet rs = cmd.ExecuteResultSet(ResultSetOptions.Scrollable | ResultSetOptions.Updatable);
Cursores estáticos
Um cursor estático, chamado de cursor de consulta rolável nas versões anteriores do SQL Server Compact 3.5, cria e armazena uma cópia completa do conjunto de resultados. Os dados de valores grandes recuperados quando um usuário os solicita explicitamente são exceção. Este conjunto de resultados é preenchido somente quando necessário. Isso é diferente de SQL Server, que preenche o conjunto de resultados durante a criação do cursor. Os cursores estáticos oferecem suporte à rolagem para frente e para trás, mas não às atualizações. Os cursores estáticos não vêem alterações externas feitas em dados sem distinção. Os resultados da consulta são armazenados em cache pelo tempo de vida útil do cursor. Embora os cursores estáticos sejam mais funcionais que os de somente avanço, eles são mais lentos e usam mais memória. Recomendamos que você use os cursores estáticos apenas se a rolagem for necessária e um cursor de conjunto de chaves não for apropriado.
A seguir, um exemplo de como obter um cursor estático usando ADO .NET:
cmd.CommandText = "Select * from tablename";
SqlCeResultSet rs = cmd.ExecuteResultSet(ResultSetOptions.Scrollable | ResultSetOptions.Insensitive);
Cursores de somente avanço
O cursor de somente avanço é o cursor atualizável mais rápido, mas ele não oferece suporte à rolagem. Ele oferece suporte apenas à busca de linhas em série do início ao final do cursor. As linhas não são recuperadas do banco de dados até que sejam buscadas. Os efeitos de todas as instruções INSERT, UPDATE e DELETE feitas pelo usuário atual ou confirmadas por outros usuários que afetam as linhas no conjunto de resultados são visíveis como as linhas buscadas a partir do cursor. Como o cursor não pode ser rolado para trás, a maioria das alterações feitas nas linhas do banco de dados depois que a linha é buscada não fica visível quando se usa o cursor.
Os cursores de somente avanço e somente leitura são os cursores baseados em consultas mais rápidos. Eles devem ser usados em cenários nos quais velocidade e volume de memória são mais importantes.
A seguir, um exemplo de como obter um cursor de somente avanço usando ADO .NET:
cmd.CommandText = "Select * from tablename";
SqlCeResultSet rs = cmd.ExecuteResultSet(ResultSetOptions.Updatable);
Cursores de somente avanço/somente leitura
Os cursores de somente avanço/somente leitura, chamados de cursores de somente avanço nas versões anteriores do SQL Server Compact 3.5, são os mais rápidos, mas não podem ser atualizados.
A seguir, um exemplo de como obter um cursor de somente avanço/somente leitura usando ADO .NET:
cmd.CommandText = "Select * from tablename";
SqlCeResultSet rs = cmd.ExecuteResultSet(ResultSetOptions.None);
Observação Você não pode criar cursores de somente leitura na consulta que retorna apenas colunas de somente leitura, pois, internamente, todos os cursores do SQL Server Compact 3.5 são atualizáveis. O SQL Server Compact 3.5 não pode atualizar as colunas de somente leitura retornadas no SqlCeResultSet. Assim, poderá haver uma falha com o erro “Não é possível gerar um cursor atualizável para a consulta, pois não há uma coluna atualizável.”
Cursores controlados por conjuntos de chaves
O cursor controlado por conjunto de chaves no SQL Server Compact 3.5 é um cursor rolável que você pode atualizar. Um cursor controlado por conjunto de chaves é controlado por um conjunto de identificadores físicos conhecido como conjunto de chaves. O conjunto de chaves tem como base todas as linhas qualificadas para a instrução SELECT no momento que o cursor foi aberto. O conjunto de chaves é criado em uma tabela temporária quando o cursor é aberto. Com o cursor controlado por conjunto de chaves, a associação é determinada no momento que a consulta é executada.
Os cursores controlados por conjuntos de chaves no SQL Server Compact 3.5 diferem um pouco dos cursores do SQL Server. No SQL Server, o cursor controlado por conjunto de chaves usa um conjunto de identificadores exclusivos como as chaves no conjunto de chaves. No SQL Server Compact 3.5, as chaves são indicadores de onde os valores são logicamente armazenados em uma tabela. Não são identificadores exclusivos.
Embora seja sensível a diversas alterações, um cursor controlado por conjunto de chaves não é sensível como os outros cursores. Por exemplo, uma inserção fora do cursor não será vista, embora as inserções dentro dele sejam exibidas no final. Nesse caso, recomendamos que você feche e abra o cursor novamente ou use um dos cursores de somente avanço.
Como o SQL Server Compact 3.5 usa indicadores para definir um conjunto de chaves, todas as alterações nos valores dos dados das linhas incluídas no conjunto de chaves são visíveis quando se usa o cursor. Isso ocorre nas alterações feitas dentro e fora dos cursores.
Qualquer exclusão feita em um cursor de conjunto de chaves, seja dentro ou fora dele, fará com que a linha seja relatada como excluída, se uma tentativa de buscá-la for efetuada.
A seguir, um exemplo de como obter um cursor controlado por conjunto de chaves usando ADO .NET:
cmd.CommandText = "Select * from tablename";
SqlCeResultSet rs = cmd.ExecuteResultSet(ResultSetOptions.Scrollable | ResultSetOptions.Updatable);
Trabalhando com associações
Se a consulta que você usa para abrir um cursor controlado por conjunto de chaves incluir colunas associadas, essas colunas não poderão ser atualizadas. O usuário pode inserir novos valores nessas colunas, mas não há suporte para atualizações.
Se o conjunto de chaves for usado para preencher um controle atualizável pelo usuário, como um objeto DataGrid, os usuários poderão tentar atualizar os valores no controle e a atualização falhará. Se você estiver desenvolvendo um aplicativo que usa um DataGrid para exibir dados de colunas associadas, verifique se as colunas associadas foram definidas no DataGrid como Somente leitura.