Um cursor no SQL Server é um d objeto de banco de dados que nos permite recuperar cada linha por vez e manipular seus dados . Um cursor nada mais é do que um ponteiro para uma linha. É sempre usado em conjunto com uma instrução SELECT. Geralmente é uma coleção de SQL lógica que percorre um número predeterminado de linhas, uma por uma. Uma ilustração simples do cursor é quando temos um extenso banco de dados de registros de trabalhadores e queremos calcular o salário de cada trabalhador após dedução de impostos e licenças.
O SQL Server o objetivo do cursor é atualizar os dados linha por linha, alterá-los ou realizar cálculos que não são possíveis quando recuperamos todos os registros de uma vez . Também é útil para executar tarefas administrativas, como backups de banco de dados SQL Server em ordem sequencial. Os cursores são usados principalmente nos processos de desenvolvimento, DBA e ETL.
Este artigo explica tudo sobre o cursor do SQL Server, como ciclo de vida do cursor, por que e quando o cursor é usado, como implementar cursores, suas limitações e como podemos substituir um cursor.
Ciclo de vida do cursor
Podemos descrever o ciclo de vida de um cursor no cinco seções diferentes do seguinte modo:
1: Declarar Cursor
A primeira etapa é declarar o cursor usando a instrução SQL abaixo:
concatenação de strings
DECLARE cursor_name CURSOR FOR select_statement;
Podemos declarar um cursor especificando seu nome com o tipo de dados CURSOR após a palavra-chave DECLARE. Em seguida, escreveremos a instrução SELECT que define a saída do cursor.
2: Cursor aberto
É uma segunda etapa em que abrimos o cursor para armazenar os dados recuperados do conjunto de resultados. Podemos fazer isso usando a instrução SQL abaixo:
OPEN cursor_name;
3: Buscar Cursor
É uma terceira etapa na qual as linhas podem ser buscadas uma por uma ou em um bloco para fazer manipulação de dados como operações de inserção, atualização e exclusão na linha atualmente ativa no cursor. Podemos fazer isso usando a instrução SQL abaixo:
FETCH NEXT FROM cursor INTO variable_list;
Também podemos usar o Função @@FETCHSTATUS no SQL Server para obter o status do cursor da instrução FETCH mais recente que foi executado no cursor. O BUSCAR a instrução foi bem-sucedida quando @@FETCHSTATUS fornece saída zero. O ENQUANTO instrução pode ser usada para recuperar todos os registros do cursor. O código a seguir explica isso mais claramente:
WHILE @@FETCH_STATUS = 0 BEGIN FETCH NEXT FROM cursor_name; END;
4: Fechar Cursor
É a quarta etapa em que o cursor deve ser fechado após terminarmos de trabalhar com o cursor. Podemos fazer isso usando a instrução SQL abaixo:
CLOSE cursor_name;
5: Cursor de desalocação
É a quinta e última etapa em que apagaremos a definição do cursor e liberaremos todos os recursos do sistema associados ao cursor. Podemos fazer isso usando a instrução SQL abaixo:
DEALLOCATE cursor_name;
Usos do cursor do SQL Server
Sabemos que os sistemas de gerenciamento de banco de dados relacional, incluindo o SQL Server, são excelentes no tratamento de dados em um conjunto de linhas chamado conjuntos de resultados. Por exemplo , temos uma mesa tabela_de_produtos que contém as descrições dos produtos. Se quisermos atualizar o preço do produto, então o abaixo ' ATUALIZAR' consulta atualizará todos os registros que correspondem à condição no ' ONDE' cláusula:
UPDATE product_table SET unit_price = 100 WHERE product_id = 105;
Às vezes, o aplicativo precisa processar as linhas de maneira singleton, ou seja, linha por linha, em vez de todo o conjunto de resultados de uma só vez. Podemos fazer esse processo usando cursores no SQL Server. Antes de usar o cursor, devemos saber que os cursores têm um desempenho muito ruim, por isso devemos sempre usá-los apenas quando não houver outra opção exceto o cursor.
O cursor usa a mesma técnica que usamos loops como FOREACH, FOR, WHILE, DO WHILE para iterar um objeto por vez em todas as linguagens de programação. Portanto, pode ser escolhido porque aplica a mesma lógica do processo de loop da linguagem de programação.
Tipos de cursores no SQL Server
A seguir estão os diferentes tipos de cursores no SQL Server listados abaixo:
- Cursores estáticos
- Cursores Dinâmicos
- Cursores somente para frente
- Cursores de conjunto de teclas
Cursores estáticos
O conjunto de resultados mostrado pelo cursor estático é sempre o mesmo de quando o cursor foi aberto pela primeira vez. Como o cursor estático armazenará o resultado em tempdb , eles estão sempre somente leitura . Podemos usar o cursor estático para avançar e retroceder. Ao contrário de outros cursores, é mais lento e consome mais memória. Como resultado, só podemos usá-lo quando a rolagem for necessária e outros cursores não forem adequados.
Este cursor mostra as linhas que foram removidas do banco de dados após sua abertura. Um cursor estático não representa nenhuma operação INSERT, UPDATE ou DELETE (a menos que o cursor seja fechado e reaberto).
Cursores Dinâmicos
Os cursores dinâmicos são opostos aos cursores estáticos que nos permitem realizar as operações de atualização, exclusão e inserção de dados enquanto o cursor está aberto. Isso é rolável por padrão . Ele pode detectar todas as alterações feitas nas linhas, ordem e valores no conjunto de resultados, quer as alterações ocorram dentro ou fora do cursor. Fora do cursor, não podemos ver as atualizações até que sejam confirmadas.
Cursores somente para frente
É o tipo de cursor padrão e mais rápido entre todos os cursores. É chamado de cursor somente para frente porque avança apenas através do conjunto de resultados . Este cursor não suporta rolagem. Ele só pode recuperar linhas do início ao fim do conjunto de resultados. Ele nos permite realizar operações de inserção, atualização e exclusão. Aqui, o efeito das operações de inserção, atualização e exclusão feitas pelo usuário que afetam as linhas no conjunto de resultados são visíveis à medida que as linhas são buscadas no cursor. Quando a linha foi buscada, não podemos ver as alterações feitas nas linhas através do cursor.
Os cursores somente encaminhamento são categorizados em três tipos:
caractere para int em java
- Conjunto de chaves Forward_Only
- Forward_Only Estático
- Avanço rápido
Cursores acionados por conjunto de chaves
Esta funcionalidade de cursor fica entre um cursor estático e um dinâmico em relação à sua capacidade de detectar alterações. Nem sempre é possível detectar alterações na associação e na ordem do conjunto de resultados como um cursor estático. Ele pode detectar alterações nos valores das linhas do conjunto de resultados como um cursor dinâmico. Só pode passar da primeira para a última e da última para a primeira linha . A ordem e a adesão são fixadas sempre que este cursor é aberto.
Ele é operado por um conjunto de identificadores exclusivos iguais às chaves do conjunto de chaves. O conjunto de chaves é determinado por todas as linhas que qualificaram a instrução SELECT quando o cursor foi aberto pela primeira vez. Ele também pode detectar quaisquer alterações na fonte de dados, que oferece suporte a operações de atualização e exclusão. É rolável por padrão.
Implementação de Exemplo
Vamos implementar o exemplo do cursor no servidor SQL. Podemos fazer isso primeiro criando uma tabela chamada ' cliente 'usando a instrução abaixo:
CREATE TABLE customer ( id int PRIMARY KEY, c_name nvarchar(45) NOT NULL, email nvarchar(45) NOT NULL, city nvarchar(25) NOT NULL );
A seguir, inseriremos valores na tabela. Podemos executar a instrução abaixo para adicionar dados em uma tabela:
INSERT INTO customer (id, c_name, email, city) VALUES (1,'Steffen', '[email protected]', 'Texas'), (2, 'Joseph', '[email protected]', 'Alaska'), (3, 'Peter', '[email protected]', 'California'), (4,'Donald', '[email protected]', 'New York'), (5, 'Kevin', '[email protected]', 'Florida'), (6, 'Marielia', '[email protected]', 'Arizona'), (7,'Antonio', '[email protected]', 'New York'), (8, 'Diego', '[email protected]', 'California');
Podemos verificar os dados executando o SELECIONAR declaração:
SELECT * FROM customer;
Depois de executar a consulta, podemos ver a saída abaixo onde temos oito linhas na mesa:
Agora, criaremos um cursor para exibir os registros do cliente. Os trechos de código abaixo explicam todas as etapas da declaração ou criação do cursor juntando tudo:
js definir tempo limite
--Declare the variables for holding data. DECLARE @id INT, @c_name NVARCHAR(50), @city NVARCHAR(50) --Declare and set counter. DECLARE @Counter INT SET @Counter = 1 --Declare a cursor DECLARE PrintCustomers CURSOR FOR SELECT id, c_name, city FROM customer --Open cursor OPEN PrintCustomers --Fetch the record into the variables. FETCH NEXT FROM PrintCustomers INTO @id, @c_name, @city --LOOP UNTIL RECORDS ARE AVAILABLE. WHILE @@FETCH_STATUS = 0 BEGIN IF @Counter = 1 BEGIN PRINT 'id' + CHAR(9) + 'c_name' + CHAR(9) + CHAR(9) + 'city' PRINT '--------------------------' END --Print the current record PRINT CAST(@id AS NVARCHAR(10)) + CHAR(9) + @c_name + CHAR(9) + CHAR(9) + @city --Increment the counter variable SET @Counter = @Counter + 1 --Fetch the next record into the variables. FETCH NEXT FROM PrintCustomers INTO @id, @c_name, @city END --Close the cursor CLOSE PrintCustomers --Deallocate the cursor DEALLOCATE PrintCustomers
Após executar um cursor, obteremos a saída abaixo:
Limitações do cursor do SQL Server
Um cursor tem algumas limitações, por isso deve sempre ser usado apenas quando não há outra opção exceto o cursor. Essas limitações são:
- O cursor consome recursos de rede, exigindo uma viagem de ida e volta à rede cada vez que busca um registro.
- Um cursor é um conjunto de ponteiros residentes na memória, o que significa que ocupa alguma memória que outros processos poderiam usar em nossa máquina.
- Ele impõe bloqueios em uma parte da tabela ou em toda a tabela ao processar dados.
- O desempenho e a velocidade do cursor são mais lentos porque eles atualizam os registros da tabela uma linha por vez.
- Os cursores são mais rápidos que os loops while, mas têm mais sobrecarga.
- O número de linhas e colunas colocadas no cursor é outro aspecto que afeta a velocidade do cursor. Refere-se a quanto tempo leva para abrir o cursor e executar uma instrução de busca.
Como podemos evitar cursores?
A principal função dos cursores é percorrer a tabela linha por linha. A maneira mais fácil de evitar cursores é fornecida abaixo:
Usando o loop SQL while
A maneira mais fácil de evitar o uso de cursor é usar um loop while que permite a inserção de um conjunto de resultados na tabela temporária.
Funções definidas pelo usuário
Às vezes, cursores são usados para calcular o conjunto de linhas resultante. Podemos fazer isso usando uma função definida pelo usuário que atenda aos requisitos.
Usando junções
Join processa apenas as colunas que atendem à condição especificada e, portanto, reduz as linhas de código que fornecem desempenho mais rápido do que os cursores, caso registros grandes precisem ser processados.