One place for hosting & domains

      Gerenciar

      Como gerenciar e utilizar acionadores de banco de dados do MySQL no Ubuntu 18.04


      O autor selecionou a Apache Software Foundation para receber uma doação como parte do programa Write for DOnations.

      Introdução

      No MySQL, um acionador é um comando SQL definido por usuário que é chamado automaticamente durante uma operação INSERT, DELETE, ou UPDATE. O código de acionador está associado a uma tabela e é destruído assim que uma tabela for descartada. Você pode especificar um momento de ação do acionador e definir se ele será ativado antes ou após o evento de banco de dados definido.

      Os acionadores possuem várias vantagens. Por exemplo, você pode usá-los para gerar o valor de uma coluna derivada durante uma instrução de INSERT. Outro caso de uso é a aplicação da integridade referencial, onde é possível utilizar um acionador para salvar um registro em várias tabelas relacionadas. Outros benefícios dos acionadores incluem o registro de ações do usuário para auditar tabelas, bem como cópias de dados em tempo real em diferentes esquemas de bancos de dados para fins de redundância, com o objetivo de evitar um único ponto de falha.

      Você também pode utilizar acionadores para manter as regras de validação no nível do banco de dados. Isso ajuda no compartilhamento da fonte de dados em vários aplicativos, sem quebrar a lógica de negócios. Isso também reduz bastante os testes de viagem de ida e volta para o servidor de banco de dados, o que, portanto, melhora o tempo de resposta dos seus aplicativos. Como o servidor de banco de dados executa os acionadores, eles podem aproveitar-se de recursos de servidor melhorados, como RAM e CPU.

      Neste tutorial, você criará, utilizará e excluirá vários tipos de acionadores no seu banco de dados do MySQL.

      Pré-requisitos

      Antes de começar, certifique-se de ter o seguinte:

      Passo 1 — Criando um banco de dados de amostra

      Neste passo, você criará um banco de dados de clientes de amostra com várias tabelas para demonstrar como os acionadores do MySQL funcionam.

      Para entender melhor sobre as consultas do MySQL, leia nossa Introdução às consultas no MySQL.

      Primeiro, faça login no seu servidor do MySQL como raiz:

      Digite sua senha raiz do MySQL quando solicitado e clique em ENTER para continuar. Quando você vir o prompt do mysql>, execute o seguinte comando para criar um banco de dados test_db:

      Output

      Query OK, 1 row affected (0.00 sec)

      Em seguida, mude para o test_db com:

      Output

      Database changed

      Você começará criando uma tabela de customers. Essa tabela terá os registros dos clientes, incluindo a customer_id, o customer_name e o level. Haverá dois níveis de clientes: BASIC e VIP.

      • Create table customers(customer_id BIGINT PRIMARY KEY, customer_name VARCHAR(50), level VARCHAR(50) ) ENGINE=INNODB;

      Output

      Query OK, 0 rows affected (0.01 sec)

      Agora, adicione alguns registros à tabela customers. Para fazer isso, execute os comandos um a um:

      • Insert into customers (customer_id, customer_name, level )values('1','JOHN DOE','BASIC');
      • Insert into customers (customer_id, customer_name, level )values('2','MARY ROE','BASIC');
      • Insert into customers (customer_id, customer_name, level )values('3','JOHN DOE','VIP');

      Você verá o seguinte resultado após executar cada um dos comandos INSERT:

      Output

      Query OK, 1 row affected (0.01 sec)

      Para garantir que os registros de amostra foram inseridos com sucesso, execute o comando SELECT:

      Output

      +-------------+---------------+-------+ | customer_id | customer_name | level | +-------------+---------------+-------+ | 1 | JOHN DOE | BASIC | | 2 | MARY ROE | BASIC | | 3 | JOHN DOE | VIP | +-------------+---------------+-------+ 3 rows in set (0.00 sec)

      Você criará também outra tabela para reter informações relacionadas sobre a conta customers. A tabela terá os campos customer_id e status_notes.

      Execute o seguinte comando:

      • Create table customer_status(customer_id BIGINT PRIMARY KEY, status_notes VARCHAR(50)) ENGINE=INNODB;

      Em seguida, você criará uma tabela de sales (vendas). Esta tabela terá os dados de vendas relacionados a diferentes clientes através da coluna customer_id:

      • Create table sales(sales_id BIGINT PRIMARY KEY, customer_id BIGINT, sales_amount DOUBLE ) ENGINE=INNODB;

      Output

      Query OK, 0 rows affected (0.01 sec)

      Você adicionará os dados da amostra aos dados de sales nos passos próximos, enquanto testa os acionadores. Em seguida, crie uma tabela audit_log para registrar as atualizações feitas para a tabela de sales quando você implementar o acionador AFTER UPDATE no Passo 5:

      • Create table audit_log(log_id BIGINT PRIMARY KEY AUTO_INCREMENT, sales_id BIGINT, previous_amount DOUBLE, new_amount DOUBLE, updated_by VARCHAR(50), updated_on DATETIME ) ENGINE=INNODB;

      Output

      Query OK, 0 rows affected (0.02 sec)

      Com o banco de dados test_db e as quatro tabelas em funcionamento, siga em frente para trabalhar com os vários acionadores do MySQL no seu banco de dados.

      Passo 2 — Criando um acionador antes de inserir

      Neste passo, você examinará a sintaxe de um acionador do MySQL, antes da aplicação dessa lógica para criar um acionador BEFORE INSERT, que valida o campo sales_amount quando os dados são inseridos na tabela de sales.

      A sintaxe geral para a criação de um acionador do MySQL é mostrada no exemplo a seguir:

      DELIMITER //
      CREATE TRIGGER [TRIGGER_NAME]
      [TRIGGER TIME] [TRIGGER EVENT]
      ON [TABLE]
      FOR EACH ROW
      [TRIGGER BODY]//
      DELIMITER ;
      

      A estrutura do acionador inclui:

      DELIMITER //: o delimitador padrão do MySQL é o ; — ele é necessário para modificá-lo para outra coisa, de modo a permitir que o MySQL trate as linhas seguintes como um comando até que ele atinja seu delimitador personalizado. Neste exemplo, o delimitador é alterado para // e, em seguida, o delimitador ; é redefinido no final.

      [TRIGGER_NAME]: um acionador deve ter um nome e é aqui que você inclui o valor.

      [TRIGGER TIME]: um acionador pode ser chamado durante diferentes intervalos de tempo. O MySQL permite que você defina se o acionador iniciará antes ou após uma operação de banco de dados.

      [TRIGGER EVENT]: os acionadores são chamados apenas por operações de INSERT, UPDATE e DELETE. Você pode utilizar qualquer valor aqui, dependendo do que quiser fazer.

      [TABLE]: qualquer acionador que você criar no seu banco de dados do MySQL deve estar associado a uma tabela.

      FOR EACH ROW: essa instrução diz ao MySQL para executar o código do acionador para cada linha que o acionador afeta.

      [TRIGGER BODY]​​​: o código que é executado quando o acionador é chamado tem o nome de trigger body. Pode ser uma única instrução do SQL ou vários comandos. Note que, se estiver executando várias instruções do SQL no corpo do acionador, você deve envolvê-las entre um bloco BEGIN... END.

      Nota: ao criar o corpo do acionador, você pode utilizar as palavras-chave OLD e NEW para acessar os valores de coluna antigos e novos inseridos durante uma operação INSERT, UPDATE e DELETE. Em um acionador de DELETE, apenas a palavra-chave OLD pode ser usada (que você usará no Passo 4).

      Agora, você criará seu primeiro acionador BEFORE INSERT. Este acionador estará associado à tabela de sales e será chamado antes de um registro ser inserido para validar o sales_amount. A função do acionador é a de verificar se o sales_amount que está sendo inserido no quadro de vendas é maior do que 10000 e de gerar um erro, caso isso seja verdadeiro.

      Certifique-se de estar logado no servidor do MySQL. Em seguida, digite os comandos do MySQL seguintes um de cada vez:

      • DELIMITER //
      • CREATE TRIGGER validate_sales_amount
      • BEFORE INSERT
      • ON sales
      • FOR EACH ROW
      • IF NEW.sales_amount>10000 THEN
      • SIGNAL SQLSTATE '45000'
      • SET MESSAGE_TEXT = 'Sale has exceeded the allowed amount of 10000.';
      • END IF//
      • DELIMITER ;

      Você está usando a instrução IF... THEN... END IF para avaliar se a quantidade que está sendo fornecida durante a instrução INSERT está dentro da sua faixa. O acionador consegue extrair o novo valor de sales_amount que está sendo fornecido, usando a palavra-chave NEW.

      Para gerar uma mensagem de erro genérica, use as linhas seguintes para informar o usuário sobre o erro:

      SIGNAL SQLSTATE '45000'
      SET MESSAGE_TEXT = 'Sale has exceeded the allowed amount of 10000.';
      

      Em seguida, insira um registro com um sales_amount de 11000 para a tabela de sales para verificar se o acionador interromperá a operação:

      • Insert into sales(sales_id, customer_id, sales_amount) values('1','1','11000');

      Output

      ERROR 1644 (45000): Sale has exceeded the allowed amount of 10000.

      Este erro mostra que o código do acionador está funcionando como esperado.

      Agora, teste um novo registro com um valor de 7500 para verificar se o comando será bem-sucedido:

      • Insert into sales(sales_id, customer_id, sales_amount) values('1','1','7500');

      Como o valor está dentro da faixa recomendada, você verá o seguinte resultado:

      Output

      Query OK, 1 row affected (0.01 sec)

      Para confirmar que os dados foram inseridos, execute o seguinte comando:

      O resultado confirma que os dados estão na tabela:

      Output

      +----------+-------------+--------------+ | sales_id | customer_id | sales_amount | +----------+-------------+--------------+ | 1 | 1 | 7500 | +----------+-------------+--------------+ 1 row in set (0.00 sec)

      Neste passo, você testou os acionadores para validar dados antes da inserção deles em um banco de dados.

      Em seguida, você trabalhará com o acionador AFTER INSERT para salvar informações relacionadas em tabelas diferentes.

      Passo 3 — Criando um acionador após inserir

      Os acionadores AFTER INSERT são executados quando os registros são inseridos com sucesso em uma tabela. Essa funcionalidade pode ser usada para executar outras lógicas relacionados a negócios de maneira automática. Por exemplo, em um aplicativo bancário, um acionador AFTER INSERT pode fechar uma conta de empréstimo quando um cliente terminar de pagar o empréstimo. O acionador pode monitorar todos os pagamentos inseridos em uma tabela de transação e fechar o empréstimo automaticamente assim que o saldo do empréstimo se tornar zero.

      Neste passo, você trabalhará com sua tabela de customer_status usando um acionador AFTER INSERT para digitar registros de clientes relacionados.

      Para criar o acionador AFTER INSERT, digite os comandos a seguir:

      • DELIMITER //
      • CREATE TRIGGER customer_status_records
      • AFTER INSERT
      • ON customers
      • FOR EACH ROW
      • Insert into customer_status(customer_id, status_notes) VALUES(NEW.customer_id, 'ACCOUNT OPENED SUCCESSFULLY')//
      • DELIMITER ;

      Output

      Query OK, 0 rows affected (0.00 sec)

      Aqui, você instruirá o MySQL para salvar outro registro para a tabela customer_status assim que um novo registro de cliente for inserido na tabela customers.

      Agora, insira um novo registro na tabela customers para confirmar que seu código do acionador será chamado:

      • Insert into customers (customer_id, customer_name, level )values('4','DAVID DOE','VIP');

      Output

      Query OK, 1 row affected (0.01 sec)

      Como o registro foi inserido com sucesso, verifique se um novo registro de status foi inserido na tabela customer_status:

      • Select * from customer_status;

      Output

      +-------------+-----------------------------+ | customer_id | status_notes | +-------------+-----------------------------+ | 4 | ACCOUNT OPENED SUCCESSFULLY | +-------------+-----------------------------+ 1 row in set (0.00 sec)

      O resultado confirma que o acionador foi executado com sucesso.

      O acionador AFTER INSERT é útil no monitoramento do ciclo de vida de um cliente. Em um ambiente de produção, as contas dos clientes podem ser submetidas a diferentes etapas, como a abertura da conta, a suspensão da conta e o fechamento da conta.

      Nos passos a seguir, você trabalhará com os acionadores de UPDATE.

      Passo 4 — Criando um acionador antes de atualizar

      Um acionador BEFORE UPDATE é semelhante ao acionador BEFORE INSERT—a diferença é o momento onde eles são chamados. Você pode utilizar o acionador BEFORE UPDATE para verificar uma lógica de negócios antes de um registro ser atualizado. Para testar isso, você utilizará a tabela customers, na qual você já inseriu alguns dados.

      Você tem dois níveis para seus clientes no banco de dados. Neste exemplo, assim que uma conta de cliente for atualizada para o nível VIP, a conta não poderá ser rebaixada para o nível BASIC. Para aplicar essa regra, você criará um acionador BEFORE UPDATE que executará antes da instrução UPDATE, como mostrado a seguir. Se um usuário de banco de dados tentar rebaixar um cliente do nível VIP para o nível BASIC, será acionada uma exceção definida pelo usuário.

      Digite os comandos SQL seguintes um de cada vez para criar o acionador BEFORE UPDATE:

      • DELIMITER //
      • CREATE TRIGGER validate_customer_level
      • BEFORE UPDATE
      • ON customers
      • FOR EACH ROW
      • IF OLD.level='VIP' THEN
      • SIGNAL SQLSTATE '45000'
      • SET MESSAGE_TEXT = 'A VIP customer can not be downgraded.';
      • END IF //
      • DELIMITER ;

      Use a palavra-chave OLD para capturar o nível que o usuário está fornecendo ao executar o comando UPDATE. Novamente, use a instrução IF... THEN… END IF para sinalizar uma instrução de erro genérica para o usuário.

      Em seguida, execute o comando SQL a seguir, que tenta rebaixar uma conta de cliente associada ao customer_id de 3:

      • Update customers set level='BASIC' where customer_id='3';

      Você verá o seguinte resultado, fornecendo o SET MESSAGE_TEXT:

      Output

      ERROR 1644 (45000): A VIP customer can not be downgraded.

      Se executar o mesmo comando para um cliente de nível BASIC e tentar atualizar a conta para o nível VIP, o comando será executado com sucesso:

      • Update customers set level='VIP' where customer_id='1';

      Output

      Rows matched: 1 Changed: 1 Warnings: 0

      Você usou o acionador BEFORE UPDATE para aplicar uma regra de negócios. Agora, siga em frente para usar um acionador AFTER UPDATE para log de auditoria.

      Passo 5 — Criando um acionador após atualizar

      Um acionador AFTER UPDATE é chamado assim que um registro de banco de dados for atualizado com sucesso. Este comportamento torna o acionador adequado para o log de auditoria. Em um ambiente de muitos usuários, o administrador pode querer exibir um histórico de usuários atualizando os registros em uma tabela específica para fins de auditoria.

      Você criará um acionador que registra a atividade de atualização da tabela sales. Nossa tabela audit_log terá as informações sobre os usuários do MySQL atualizando a tabela de sales, a date da atualização e os valores old e new da sales_amount.

      Para criar o acionador, execute os comandos SQL seguintes:

      • DELIMITER //
      • CREATE TRIGGER log_sales_updates
      • AFTER UPDATE
      • ON sales
      • FOR EACH ROW
      • Insert into audit_log(sales_id, previous_amount, new_amount, updated_by, updated_on) VALUES (NEW.sales_id,OLD.sales_amount, NEW.sales_amount,(SELECT USER()), NOW() )//
      • DELIMITER ;

      Insira um novo registro para a tabela audit_log. Use a palavra-chave NEW para recuperar o valor do sales_id e o novo sales_amount. Além disso, use a palavra-chave OLD para recuperar o sales_amount anterior, já que deseja registrar ambos os montantes para fins de auditoria.

      O comando SELECT USER() recupera o usuário atual que executa a operação e a instrução NOW() recupera o valor da data e hora atual do servidor MySQL.

      Agora, caso um usuário tente atualizar o valor de qualquer registro na tabela sales, o acionador log_sales_updates inserirá um novo registro para a tabela audit_log.

      Vamos criar um novo registro de vendas com uma sales_id aleatória de 5 e tentar atualizá-lo. Primeiro, insira o registro de vendas com:

      • Insert into sales(sales_id, customer_id, sales_amount) values('5', '2','8000');

      Output

      Query OK, 1 row affected (0.00 sec)

      Em seguida, atualize o registro:

      • Update sales set sales_amount='9000' where sales_id='5';

      Você verá o seguinte resultado:

      Output

      Rows matched: 1 Changed: 1 Warnings: 0

      Agora, execute o comando a seguir para verificar se o acionador AFTER UPDATE conseguiu registrar um novo registro na tabela audit_log:

      O acionador registrou a atualização Seu resultado mostra o sales_amount e o new amount previamente registrados com o usuário que atualizou os registros:

      Output

      +--------+----------+-----------------+------------+----------------+---------------------+ | log_id | sales_id | previous_amount | new_amount | updated_by | updated_on | +--------+----------+-----------------+------------+----------------+---------------------+ | 1 | 5 | 8000 | 9000 | root@localhost | 2019-11-07 09:28:36 | +--------+----------+-----------------+------------+----------------+---------------------+ 1 row in set (0.00 sec)

      Você também tem a data e hora que a atualização foi realizada, que são valiosos para fins de auditoria.

      Em seguida, você usará o acionador DELETE para aplicar a integridade da referenciação no nível de banco de dados.

      Passo 6 — Criando um acionador antes de excluir

      Acionadores do BEFORE DELETE são chamados antes que uma instrução DELETE seja executada em uma tabela. Normalmente, esses tipos de acionadores são usados para aplicar a integridade referencial em diferentes tabelas relacionadas. Por exemplo, cada registro da tabela de sales se relaciona a um customer_id da tabela customers. Se um usuário excluísse um registro da tabela customers que tem um registro relacionado na tabela sales, você não teria como saber qual era o cliente associado àquele registro.

      Para evitar isso, é possível criar um acionador BEFORE DELETE para aplicar sua lógica. Execute os comandos SQL a seguir, um de cada vez:

      • DELIMITER //
      • CREATE TRIGGER validate_related_records
      • BEFORE DELETE
      • ON customers
      • FOR EACH ROW
      • IF OLD.customer_id in (select customer_id from sales) THEN
      • SIGNAL SQLSTATE '45000'
      • SET MESSAGE_TEXT = 'The customer has a related sales record.';
      • END IF//
      • DELIMITER ;

      Agora, tente excluir um cliente que tenha um registro de vendas relacionado a ele:

      • Delete from customers where customer_id='2';

      Como resultado, você verá a seguinte saída:

      Output

      ERROR 1644 (45000): The customer has a related sales record.

      O acionador BEFORE DELETE pode evitar a exclusão acidental de informações relacionadas em um banco de dados.

      No entanto, em algumas situações, você pode querer excluir todos os registros associados a um registro em específico de diferentes tabelas relacionadas. Nesta situação, você usaria o acionador AFTER DELETE, que será testado no próximo passo.

      Passo 7 — Criando um acionador após excluir

      Os acionadores AFTER DELETE são ativados assim que um registro tenha sido excluído com sucesso. Um exemplo de como se pode utilizar um acionador AFTER DELETE é uma situação em que o nível de desconto que um determinado cliente recebe é determinado pelo número de vendas realizadas durante um período definido. Se alguns dos registros do cliente forem excluídos da tabela de sales, o nível de desconto de cliente terá que ser rebaixado.

      Outro uso do acionador AFTER DELETE é o de excluir as informações relacionadas de outra tabela assim que um registro de uma tabela base for excluído. Por exemplo, você definirá um acionador que exclui o registro de clientes se os registros de vendas com o customer_id relacionado forem excluídos da tabela de sales. Execute o comando a seguir para criar seu acionador:

      • DELIMITER //
      • CREATE TRIGGER delete_related_info
      • AFTER DELETE
      • ON sales
      • FOR EACH ROW
      • Delete from customers where customer_id=OLD.customer_id;//
      • DELIMITER ;

      Em seguida, execute o seguinte comando para excluir todos os registros de vendas associados a um customer_id de 2:

      • Delete from sales where customer_id='2';

      Output

      Query OK, 1 row affected (0.00 sec)

      Agora, verifique se há registros para o cliente na tabela de sales:

      • Select * from customers where customer_id='2';

      Você receberá um resultado em um Empty Set, já que o registro de cliente associado ao customer_id de 2 foi excluído pelo acionador:

      Output

      Empty set (0.00 sec)

      Agora, você usou cada uma das diferentes formas de acionadores para realizar funções específicas. Em seguida, você verá como remover um acionador do banco de dados caso não precise mais dele.

      Passo 8 — Excluindo acionadores

      De maneira similar a qualquer outro objeto, você pode excluir acionadores utilizando o comando DROP. A seguir temos a sintaxe para excluir um acionador:

      Drop trigger [TRIGGER NAME];
      

      Por exemplo, para excluir o último acionador AFTER DELETE que você criou, execute o comando a seguir:

      • Drop trigger delete_related_info;

      Output

      Query OK, 0 rows affected (0.00 sec)

      A necessidade de excluir acionadores surge quando você quiser recriar a estrutura deles. Em tal caso, você pode remover o acionador e redefinir um novo com os diferentes comandos de acionador.

      Conclusão

      Neste tutorial, você criou, utilizou e excluiu diferentes tipos de acionadores de um banco de dados do MySQL. Utilizando um exemplo de banco de dados relacionados a clientes, você implementou acionadores para diferentes casos de uso, como validação de dados, aplicação de lógica de negócios, log de auditoria e aplicação da integridade referencial.

      Para obter mais informações sobre como utilizar seu banco de dados do MySQL, confira o seguinte:



      Source link

      Como gerenciar conjuntos ordenados no Redis


      Introdução

      O Redis é um repositório de dados de valor-chave na memória, de código aberto. No Redis, os conjuntos ordenados são um tipo de dados semelhante aos conjuntos, sendo ambos grupos não repetidos de strings. A diferença é que cada membro de um conjunto ordenado está associado a uma pontuação, permitindo que eles sejam ordenados da pontuação menor para a maior. Como nos conjuntos, cada membro de um conjunto ordenado deve ser único, embora vários membros possam compartilhar a mesma pontuação.

      Este tutorial explica como criar conjuntos ordenados, recuperar e remover seus membros e criar novos conjuntos ordenados a partir de dados existentes.

      Como usar este guia

      Este guia foi escrito como uma folha de referências com exemplos independentes. Encorajamos você a ir direto para as seções que sejam relevantes para a tarefa que está tentando completar.

      Os comandos mostrados neste guia foram testados em um servidor Ubuntu 18.04 executando a versão 4.0.9 do Redis. Para configurar um ambiente semelhante, siga o Passo 1 de nosso guia sobre Como instalar e proteger o Redis no Ubuntu 18.04. Vamos demonstrar como esses comandos se comportam executando-os com o redis-cli, a interface de linha de comando do Redis. Note que caso esteja usando uma interface diferente do Redis — Redli, por exemplo — o resultado exato de certos comandos pode diferir.

      De maneira alternativa, você pode provisionar uma instância de banco de dados gerenciado do Redis para testar esses comandos, mas note que, dependendo do nível de controle permitido pelo seu provedor de banco de dados, alguns comandos neste guia podem não funcionar como descrito. Para provisionar um Banco de dados gerenciado pela DigitalOcean siga nossa documentação do produto Bancos de dados gerenciados. Em seguida, você deve instalar o Redli ou configurar um túnel TLS para se conectar ao Banco de dados gerenciado através do TLS.

      Como criar conjuntos ordenados e adicionar membros

      Para criar um conjunto ordenado, use o comando zadd. O zadd aceita como argumentos o nome da chave que conterá o conjunto ordenado, seguido da pontuação do membro que você está adicionando, e do valor do membro em si. O comando a seguir criará uma chave ordenada chamada faveGuitarists com um membro, "Joe Pass", que tem uma pontuação de 1:

      • zadd faveGuitarists 1 "Joe Pass"

      O zadd retornará um número inteiro que indica a quantidade de membros que foram adicionados ao conjunto ordenado caso tenha sido criado com sucesso.

      Output

      (integer) 1

      É possível adicionar mais de um membro a um conjunto ordenado com o zadd. Note que suas pontuações não precisam ser sequenciais, podem haver lacunas entre as pontuações e vários membros mantidos no mesmo conjunto ordenado podem compartilhar a mesma pontuação:

      • zadd faveGuitarists 4 "Stephen Malkmus" 2 "Rosetta Tharpe" 3 "Bola Sete" 3 "Doug Martsch" 8 "Elizabeth Cotten" 12 "Nancy Wilson" 4 "Memphis Minnie" 12 "Michael Houser"

      Output

      (integer) 8

      O zadd pode aceitar as seguintes opções, que você deve digitar após o nome de chave e antes da primeira pontuação de membro:

      • NX ou XX: essas opções têm efeitos opostos, de modo que você só pode incluir uma delas em qualquer operação do zadd:
        • NX: diz ao zadd para não atualizar os membros existentes. Com essa opção, o zadd adicionará apenas novos elementos.
        • XX: diz ao zadd para atualizar apenas os elementos existentes. Com essa opção, o zadd nunca adicionará novos membros.
      • CH: normalmente, o zadd retorna apenas o número de novos elementos adicionados ao conjunto ordenado. Com essa opção incluída, no entanto, o zadd retornará o número de elementos alterados. Isso inclui os novos membros e membros cujas pontuações foram alteradas.
      • INCR: isso faz o comando aumentar o valor de pontuação do membro. Caso o membro ainda não exista, o comando o adicionará ao conjunto ordenado com o incremento como sendo sua pontuação, como se sua pontuação inicial fosse 0. Com o INCR incluído, o zadd retornará a nova pontuação do membro caso seja bem-sucedido. Note que você pode incluir apenas um par de pontuação/membro por vez ao usar essa opção.

      Ao invés de passar a opção INCR para o zadd, você pode, de forma alternativa, usar o comando do zincrby, que se comporta da mesma maneira. Ao invés de dar ao membro do conjunto ordenado o valor indicado pelo valor de pontuação como o zadd, ele aumentará a pontuação do membro por aquele valor. Por exemplo, o seguinte comando incrementa a pontuação do membro "Stephen Malkmus", que era originalmente 4, em 5 até 9.

      • zincrby faveGuitarists 5 "Stephen Malkmus"

      Output

      "9"

      Como acontece com a opção INCR do comando zadd, caso o membro especificado não exista, então o zincrby o criará com o valor do incremento como sua pontuação.

      Como recuperar os membros de conjuntos ordenados

      A maneira mais fundamental de recuperar os membros mantidos dentro de um conjunto ordenado é usar o comando zrange Esse comando aceita como argumentos o nome da chave cujos membros você deseja recuperar e uma faixa de membros mantidos dentro dela. A faixa é definida por dois números que representam indexações baseadas em zero, ou seja, se 0 representa o primeiro membro no conjunto ordenado (ou, o membro com a pontuação mais baixa), 1 representa o seguinte, e assim por diante.

      O exemplo a seguir retornará os primeiros quatro membros do conjunto ordenado faveGuitarists, criado na seção anterior:

      • zrange faveGuitarists 0 3

      Output

      1) "Joe Pass" 2) "Rosetta Tharpe" 3) "Bola Sete" 4) "Doug Martsch"

      Note que, caso o conjunto ordenado que você passa para o zrange tenha dois ou mais elementos que compartilham a mesma pontuação, ele ordenará esses elementos em ordem lexicográfica ou alfabética.

      As indexações de início e parada podem também ser números negativos, com -1 representando o último membro, -2 representando o penúltimo, e assim por diante:

      • zrange faveGuitarists -5 -2

      Output

      1) "Memphis Minnie" 2) "Elizabeth Cotten" 3) "Stephen Malkmus" 4) "Michael Houser"

      O zrange pode aceitar o argumento WITHSCORES que, quando incluído, também retornará as pontuações dos membros:

      • zrange faveGuitarists 5 6 WITHSCORES

      Output

      1) "Elizabeth Cotten" 2) "8" 3) "Stephen Malkmus" 4) "9"

      O zrange só pode retornar uma faixa de membros em uma ordem numérica ascendente. Para reverter isso e retornar uma faixa em ordem descendente, você deve usar o comando zrevrange. Pense neste comando como sendo uma inversão temporária da ordem do conjunto ordenado, antes de retornar os membros que se situam dentro da faixa especificada. Assim, com o zrevrange, o 0 representará o último membro mantido na chave, 1 representará o penúltimo, e assim por diante:

      • zrevrange faveGuitarists 0 5

      Output

      1) "Nancy Wilson" 2) "Michael Houser" 3) "Stephen Malkmus" 4) "Elizabeth Cotten" 5) "Memphis Minnie" 6) "Doug Martsch"

      O zrevrange também pode aceitar a opção WITHSCORES.

      É possível retornar uma faixa de membros com base nas suas pontuações com o comando zrangebyscore. No exemplo a seguir, o comando retornará todos os membros mantidos na chave faveGuitarists com uma pontuação de 2, 3, ou 4:

      • zrangebyscore faveGuitarists 2 4

      Output

      1) "Rosetta Tharpe" 2) "Bola Sete" 3) "Doug Martsch" 4) "Memphis Minnie"

      A faixa é inclusiva neste exemplo, o que significa que ela retornará os membros com pontuações de 2 ou 4. É possível excluir qualquer extremidade da faixa, precedendo-a com um parêntese aberto ((). O exemplo a seguir retornará todos os membros com uma pontuação maior ou igual a 2, mas inferior a 4:

      • zrangebyscore faveGuitarists 2 (4

      Output

      1) "Rosetta Tharpe" 2) "Bola Sete" 3) "Doug Martsch"

      Assim como com o zrange, o zrangebyscore pode aceitar o argumento WITHSCORES. Ele também aceita a opção LIMIT, que você pode usar para recuperar apenas uma seleção de elementos do resultado do zrangebyscore. Essa opção aceita uma referência, que marca o primeiro membro na faixa que o comando retornará e uma contagem, que define a quantidade de membros que o comando retornará no total. Por exemplo, o seguinte comando analisará os primeiros seis membros do conjunto ordenado faveGuitarists, mas retornará apenas três membros a partir dele, começando pelo segundo membro na faixa, representado por 1:

      • zrangebyscore faveGuitarists 0 5 LIMIT 1 3

      Output

      1) "Rosetta Tharpe" 2) "Bola Sete" 3) "Doug Martsch"

      O comando zrevrangebyscore retorna uma faixa invertida de membros com base nas suas pontuações. O seguinte comando retorna todos os membros do conjunto com uma pontuação entre 10 e 6:

      • zrevrangebyscore faveGuitarists 10 6

      Output

      1) "Stephen Malkmus" 2) "Elizabeth Cotten"

      Assim como com o zrangebyscore, o zrevrangebyscore pode aceitar as opções WITHSCORES e LIMIT. Além disso, você pode excluir qualquer uma das extremidades da faixa, precedendo-a com um parêntese aberto.

      Pode haver situações em que todos os membros em um conjunto ordenado tenham a mesma pontuação. Em tais casos, você pode forçar o redis a retornar uma faixa de elementos ordenados lexicograficamente, ou em ordem alfabética, com o comando do zrangebylex. Para testar este comando, execute o seguinte comando zadd para criar um conjunto ordenado, onde cada membro tenha a mesma pontuação:

      • zadd SomervilleSquares 0 Davis 0 Inman 0 Union 0 porter 0 magoun 0 ball 0 assembly

      O zrangebylex deve ser seguido pelo nome de uma chave, um intervalo de início e um intervalo de parada. Os intervalos de início e parada devem começar com um parêntese aberto (() ou um colchete aberto ([), como isto:

      • zrangebylex SomervilleSquares [a [z

      Output

      1) "assembly" 2) "ball" 3) "magoun" 4) "porter"

      Note que este exemplo retornou apenas quatro dos oito membros no conjunto, apesar do comando ter procurado uma faixa de a a z. Isso aconteceu porque os valores do Redis são sensíveis ao caso, de modo que os membros que começam em letra maiúscula foram excluídos do resultado. Para retornar, execute o seguinte:

      • zrangebylex SomervilleSquares [A [z

      Output

      1) "Davis" 2) "Inman" 3) "Union" 4) "assembly" 5) "ball" 6) "magoun" 7) "porter"

      O zrangebylex também aceita o caractere especial - que representam o infinito negativo e o +, que representa o infinito positivo. Assim, a sintaxe de comando a seguir retornará todos os membros do conjunto ordenado:

      • zrangebylex SomervilleSquares - +

      Note que o zrangebylex não pode retornar os membros do conjunto ordenado em uma ordem lexicográfica inversa (alfabética ascendente). Para fazer isso, use o zrevrangebylex:

      • zrevrangebylex SomervilleSquares + -

      Output

      1) "porter" 2) "magoun" 3) "ball" 4) "assembly" 5) "Union" 6) "Inman" 7) "Davis"

      Como ele é destinado a ser usado com conjuntos ordenados em que cada membro tem a mesma pontuação, o zrangebylex não aceita a opção WITHSCORES. No entanto, ele aceita a opção LIMIT.

      Como recuperar informações sobre conjuntos ordenados

      Para descobrir a quantidade de membros em um conjunto ordenado determinado (ou, em outras palavras, para determinar sua cardinalidade), use o comando zcard. O exemplo a seguir mostra a quantidade de membros sendo mantidos na chave faveGuitarists, da primeira seção deste guia:

      Output

      (integer) 9

      O zcount pode dizer a você a quantidade de elementos sendo mantidos dentro de um determinado conjunto ordenado, que se situam dentro de uma faixa de pontuações. O primeiro número que vem após a chave é o início da faixa e o segundo é o final da faixa:

      • zcount faveGuitarists 3 8

      Output

      (integer) 4

      O zscore mostra como resultado a pontuação de um membro especificado de um conjunto ordenado:

      • zscore faveGuitarists "Bola Sete"

      Output

      "3"

      Caso o membro ou a chave especificada não exista, o zscore retornará (nil).

      O zrank é semelhante ao zscore, mas, ao invés de retornar a pontuação de um determinado membro, ele retorna a classificação dele. No Redis, a classificação é um índice de base zero dos membros de um conjunto, ordenado pelas pontuações. Por exemplo, "Joe Pass" tem uma pontuação de 1, mas, como essa é a pontuação mais baixa de qualquer membro na chave, ele tem uma classificação de 0:

      • zrank faveGuitarists "Joe Pass"

      Output

      (integer) 0

      Há outro comando chamado zrevrank que executa a mesma função que o zrank, mas, de maneira contrária, inverte as classificações dos membros no conjunto. No exemplo a seguir, o membro "Joe Pass" tem a pontuação mais baixa, tendo, portanto, a classificação inversa mais elevada:

      • zrevrank faveGuitarists "Joe Pass"

      Output

      (integer) 8

      A única relação entre a pontuação de um membro e a classificação dele é onde sua pontuação fica em relação à de outros membros. Caso haja uma diferença de pontuação entre dois membros sequenciais, isso não será refletido em sua classificação. Note que, caso dois membros tenham a mesma pontuação, aquele que vem primeiro na ordem alfabética, terá a classificação inferior.

      Assim como o zscore, o zrank e zrevrank retornarão (nil) caso a chave ou o membro não exista.

      O zlexcount pode dizer a você a quantidade de membros mantida em um conjunto ordenado em uma faixa lexicográfica. O exemplo a seguir utiliza o conjunto ordenado do SomervilleSquares da seção anterior:

      • zlexcount SomervilleSquares [M [t

      Output

      (integer) 5

      Esse comando segue a mesma sintaxe que o comando zrangebylex, portanto, consulte a seção anterior para mais detalhes sobre como definir uma faixa de strings.

      Como remover os membros de conjuntos ordenados

      O comando zrem pode remover um ou mais membros de um conjunto ordenado:

      • zrem faveGuitarists "Doug Martsch" "Bola Sete"

      O zrem retornará um número inteiro, indicando a quantidade de membros removidos do conjunto ordenado:

      Output

      (integer) 2

      Há três comandos do Redis que permitem que você remova os membros de um conjunto ordenado com base em uma faixa. Por exemplo, caso cada membro em um conjunto ordenado tenha a mesma pontuação, remova os membros com base em uma faixa lexicográfica com o zremrangebylex. Esse comando utiliza a mesma sintaxe que o zrangebylex. O exemplo a seguir removerá todos os membros que começam com uma letra maiúscula da chave SomervilleSquares criada na seção anterior:

      • zremrangebylex SomervilleSquares [A [Z

      O zremrangebylex dará como resultado um número inteiro, indicando a quantidade de membros que ele removeu:

      Output

      (integer) 3

      Você também pode remover os membros com base em uma faixa de pontuações com o comando zremrangebyscore, que utiliza a mesma sintaxe que o comando zrangebyscore. O exemplo a seguir removerá todos os membros mantidos em faveGuitarists com uma pontuação de 4, 5, ou 6:

      • zremrangebyscore faveGuitarists 4 6

      Output

      (integer) 1

      Você pode remover os membros de um conjunto com base em uma faixa de classificações com o comando zremrangebyrank, que utiliza a mesma sintaxe que o zrangebyrank. O comando a seguir removerá os três membros do conjunto ordenado com as classificações mais baixas, que são definidas por uma faixa de indexações com base zero:

      • zremrangebyrank faveGuitarists 0 2

      Output

      (integer) 3

      Note que os números passados para o remrangebyrank também podem ser negativos, com -1 representando a classificação mais alta, -2 a segunda mais alta e assim por diante.

      Como criar novos conjuntos ordenados a partir de outros existentes

      O Redis inclui dois comandos que permitem que você compare os membros de vários conjuntos ordenados e crie novos com base nessas comparações: o zinterstore e o zunionstore. Para testar esses comandos, execute os comandos zadd a seguir para criar alguns exemplos de conjuntos ordenados.

      • zadd NewKids 1 "Jonathan" 2 "Jordan" 3 "Joey" 4 "Donnie" 5 "Danny"
      • zadd Nsync 1 "Justin" 2 "Chris" 3 "Joey" 4 "Lance" 5 "JC"

      O zinterstore encontra os membros compartilhados por dois ou mais conjuntos ordenados — sua intersecção — e produz um novo conjunto ordenado que contenha apenas esses membros. Esse comando deve incluir, em ordem, o nome de uma chave de destino onde os membros da intersecção serão armazenados como um conjunto ordenado, o número de chaves sendo passadas para o zinterstore e os nomes das chaves que você quer analisar:

      • zinterstore BoyBands 2 NewKids Nsync

      O zinterstore retornará um número inteiro que mostra o número de elementos armazenados no conjunto ordenado de destino. Como NewKids e Nsync compartilham apenas um membro, "Joey", o comando retornará 1:

      Output

      (integer) 1

      Esteja ciente de que, caso a chave de destino já exista, o zinterstore irá sobrescrever o conteúdo dela.

      O zunionstore criará um novo conjunto ordenado que possui todos os membros das chaves passadas a ele. Este comando utiliza a mesma sintaxe que o zinterstore e exige o nome de uma chave de destino, o número de chaves sendo passadas para o comando e os nomes das chaves:

      • zunionstore SuperGroup 2 NewKids Nsync

      Assim como o zinterstore, o zunionstore retornará um número inteiro, mostrando o número de elementos armazenados na chave de destino. Embora ambos os conjuntos ordenados originais tivessem cinco membros, como os conjuntos ordenados não podem ter membros repetidos e cada chave tem um membro chamado "Joey", o número inteiro resultante será 9:

      Output

      (integer) 9

      Assim como o zinterstore, o zunionstore irá sobrepor o conteúdo da chave de destino, caso já exista.

      Para dar mais controle sobre as pontuações dos membros ao criar novos conjuntos ordenados com o zinterstore e zunionstore, ambos esses comandos aceitam as opções WEIGHTS e AGGREGATE.

      A opção WEIGHTS vem seguida de um número para cada conjunto ordenado incluído no comando que pesa, ou multiplica, as pontuações de cada membro. O primeiro número após a opção WEIGHTS pesa as pontuações da primeira chave enviadas para o comando, o segundo número pesa a segunda chave, e assim por diante.

      O exemplo a seguir cria um conjunto ordenado novo, que possui as chaves em intersecção dos conjuntos ordenados NewKids e Nsync. Ele pesa as pontuações na chave NewKids por um fator de três e pesa as que estão na chave Nsync por um fator de sete:

      • zinterstore BoyBandsWeighted 2 NewKids Nsync WEIGHTS 3 7

      Caso a opção WEIGHTS não seja incluída, a pesagem assume o padrão 1 para o zinterstore e o zunionstore.

      O AGGREGATE aceita três subopções. O primeiro deles, SUM, implementa o comportamento padrão do zinterstore e do zunionstore, adicionando as pontuações de membros correspondentes nos conjuntos combinados.

      Caso execute uma operação zinterstore ou zunionstore em dois conjuntos ordenados que partilham um membro, mas este membro tem uma pontuação diferente em cada conjunto, você pode forçar a operação a atribuir a menor das duas pontuações no novo conjunto com a subopção MIN.

      • zinterstore BoyBandsWeightedMin 2 NewKids Nsync WEIGHTS 3 7 AGGREGATE MIN

      Como os dois conjuntos ordenados têm apenas um membro correspondente com a mesma pontuação (3), este comando criará um novo conjunto com um membro que tem o menor das duas pontuações ponderadas:

      • zscore BoyBandsWeightedMin "Joey"

      Output

      "9"

      De maneira similar, o AGGREGATE pode forçar o zinterstore ou zunionstore a atribuir a maior das duas pontuações com a opção MAX:

      • zinterstore BoyBandsWeightedMax 2 NewKids Nsync WEIGHTS 3 7 AGGREGATE MAX

      Esse comando cria um novo conjunto com um membro, "Joey", que tem a mais alto das duas pontuações ponderadas:

      • zscore BoyBandsWeightedMax "Joey"

      Output

      "21"

      É útil pensar em WEIGHTS como uma maneira de manipular temporariamente as pontuações dos membros antes de serem analisadas. De maneira similar, é útil pensar na opção AGGREGATE como uma forma de decidir como controlar as pontuações dos membros antes de serem adicionadas aos seus novos conjuntos.

      Conclusão

      Esse guia detalha vários comandos usados para criar e gerenciar conjuntos ordenados no Redis. Caso haja outros comandos, argumentos ou procedimentos relacionados que você gostaria de ver apresentados neste guia, faça perguntas ou sugestões nos comentários abaixo.

      Para obter mais informações sobre os comandos do Redis, consulte nossa série de tutoriais sobre Como gerenciar um banco de dados Redis.



      Source link

      Como Gerenciar Conjuntos no Redis


      Introdução

      O Redis é um datastore ou armazenamento de dados open-source de chave-valor na memória. Conjuntos ou Sets no Redis são coleções de strings armazenadas em uma determinada chave. Quando mantido em um conjunto, um valor de registro individual é referenciado como um member ou membro. Diferentemente das listas, os conjuntos não são ordenados e não permitem valores repetidos.

      Este tutorial explica como criar conjuntos, recuperar e remover membros e comparar os membros de conjuntos diferentes.

      Como Utilizar Este Guia

      Este guia está no formato de referência rápida com trechos de linha de comando independentes. Recomendamos que você pule para qualquer seção que seja relevante para a tarefa que você está tentando concluir.

      Os comandos mostrados neste guia foram testados em um servidor Ubuntu 18.04 executando a versão 4.0.9 do Redis. Para configurar um ambiente semelhante, você pode seguir o Passo 1 do nosso guia Como Instalar e Proteger o Redis no Ubuntu 18.04. Vamos demonstrar como esses comandos se comportam executando-os com redis-cli, a interface de linha de comando do Redis. Observe que se você estiver usando uma interface Redis diferente — Redli, por exemplo — a saída exata de certos comandos pode ser diferente.

      Como alternativa, você pode provisionar uma instância de banco de dados Redis gerenciada para testar esses comandos, mas observe que, dependendo do nível de controle permitido pelo seu provedor de banco de dados, alguns comandos neste guia podem não funcionar como descrito. Para provisionar um banco de dados gerenciado na DigitalOcean, siga nossa documentação de produto para Managed Databases. Então, você deve instalar ou o Redli ou configurar um túnel TLS para conectar-se ao banco de dados gerenciado por TLS.

      Criando Conjuntos

      O comando sadd lhe permite criar um conjunto e adicionar um ou mais membros a ele. O exemplo a seguir criará um conjunto em uma chave chamada key_horror com os membros "Frankenstein" e "Godzilla":

      • sadd key_horror "Frankenstein" "Godzilla"

      Se for bem-sucedido, o sadd retornará um número inteiro mostrando quantos membros foram adicionados ao conjunto:

      Output

      (integer) 2

      Se você tentar adicionar membros de um conjunto a uma chave que já esteja mantendo um valor não definido, ele retornará um erro. O primeiro comando neste bloco cria uma lista chamada key_action com um elemento, "Shaft". O próximo comando tenta adicionar um membro de conjunto, "Shane", à lista, mas isso produz um erro devido aos tipos de dados conflitantes:

      • rpush key_action "Shaft"
      • sadd key_action "Shane"

      Output

      (error) WRONGTYPE Operation against a key holding the wrong kind of value

      Observe que os conjuntos não permitem mais de uma ocorrência do mesmo membro:

      • sadd key_comedy "It's" "A" "Mad" "Mad" "Mad" "Mad" "Mad" "World"

      Output

      (integer) 4

      Embora esse comando sadd especifique oito membros, ele descarta quatro dos membros "Mad" repetidos, resultando em um tamanho de conjunto de 4 membros.

      Recuperando Membros de Conjuntos

      Nesta seção, abordaremos vários comandos Redis que retornam informações sobre os membros mantidos em um conjunto. Para praticar os comandos descritos aqui, execute o seguinte comando, que criará um conjunto com seis membros em uma chave chamada key_stooges:

      • sadd key_stooges "Moe" "Larry" "Curly" "Shemp" "Joe" "Curly Joe"

      Para retornar todos os membros de um conjunto, execute o comando smembers seguido da chave que você deseja inspecionar:

      Output

      1) "Curly" 2) "Moe" 3) "Larry" 4) "Shemp" 5) "Curly Joe" 6) "Joe"

      Para verificar se um valor específico é um membro de um conjunto, use o comando sismember:

      • sismember key_stooges "Harpo"

      Se o elemento "Harpo" for um membro do conjunto key_stooges, o sismember retornará 1. Caso contrário, ele retornará 0:

      Output

      (integer) 0

      Para ver quantos membros estão em um determinado conjunto (em outras palavras, para encontrar a cardinalidade de um determinado conjunto), execute scard:

      Output

      (integer) 6

      Para retornar um elemento aleatório de um conjunto, execute srandmember:

      Output

      "Larry"

      Para retornar vários elementos distintos e aleatórios de um conjunto, você pode seguir o comando srandmember com o número de elementos que você deseja recuperar:

      • srandmember key_stooges 3

      Output

      1) "Larry" 2) "Moe" 3) "Curly Joe"

      Se você passar um número negativo para srandmember, o comando poderá retornar o mesmo elemento várias vezes:

      • srandmember key_stooges -3

      Output

      1) "Shemp" 2) "Curly Joe" 3) "Curly Joe"

      A função de elemento aleatório usada no srandmember não é perfeitamente aleatória, embora seu desempenho melhore em conjuntos de dados maiores. Veja a documentação oficial do comando para mais detalhes.

      Removendo Membros de Conjuntos

      O Redis vem com três comandos usados para remover membros de um conjunto: spop,srem e smove.

      O spop seleciona aleatoriamente um número especificado de membros de um conjunto e os retorna, semelhante ao srandmember, mas depois os exclui do conjunto. Ele aceita o nome da chave que contém um conjunto e o número de membros a serem removidos do conjunto como argumentos. Se você não especificar um número, o spop assumirá o padrão de retornar e remover um único valor.

      O comando de exemplo a seguir removerá e retornará dois elementos selecionados aleatoriamente do conjunto key_stooges criado na seção anterior:

      Output

      1) "Shemp" 2) "Larry"

      O srem permite remover um ou mais membros específicos de um conjunto, em vez de membros aleatórios:

      • srem key_stooges "Joe" "Curly Joe"

      Em vez de retornar os membros removidos do conjunto, o srem retorna um número inteiro mostrando quantos membros foram removidos:

      Output

      (integer) 2

      Use o smove para mover um membro de um conjunto para outro. Este comando aceita como argumentos o conjunto de origem, o conjunto de destino e o membro a ser movido nessa ordem. Observe que o smove permite mover apenas um membro de cada vez:

      • smove key_stooges key_jambands "Moe"

      Se o comando mover o membro com sucesso, ele retornará (integer) 1:

      Output

      (integer) 1

      Se o smove falhar, ele retornará (integer) 0. Observe que se a chave de destino ainda não existir, o smove a criará antes de mover o membro para ela.

      Comparando Conjuntos

      O Redis também fornece vários comandos que encontram as diferenças e semelhanças entre os conjuntos. Para demonstrar como eles funcionam, esta seção fará referência a três conjuntos denominados presidentes, reis e beatles. Se você quiser experimentar os comandos desta seção, crie esses conjuntos e preencha-os usando os seguintes comandos sadd:

      • sadd presidents "George" "John" "Thomas" "James"
      • sadd kings "Edward" "Henry" "John" "James" "George"
      • sadd beatles "John" "George" "Paul" "Ringo"

      O sinter compara conjuntos diferentes e retorna a interseção dos conjuntos ou valores que aparecem em todos os conjuntos:

      • sinter presidents kings beatles

      Output

      1) "John" 2) "George"

      O sinterstore executa uma função semelhante, mas em vez de retornar os membros da interseção, ele cria um novo conjunto no destino especificado que contém esses membros que fazem parte da interseção. Observe que se o destino já existir, o sinterstore substituirá o seu conteúdo:

      • sinterstore new_set presidents kings beatles
      • smembers new_set

      Output

      1) "John" 2) "George"

      O sdiff retorna a diferença entre conjuntos – membros resultantes da diferença do primeiro conjunto especificado de cada um dos conjuntos seguintes:

      • sdiff presidents kings beatles

      Output

      1) "Thomas"

      Em outras palavras, sdiff examina cada membro no primeiro conjunto fornecido e, em seguida, compara-os aos membros em cada conjunto sucessivo. Qualquer membro do primeiro conjunto que também apareça nos conjuntos seguintes é removido e o sdiff retorna os membros restantes. Pense nisso como remover membros de conjuntos subsequentes a partir do primeiro conjunto.

      O sdiffstore executa uma função semelhante ao sdiff, mas, em vez de retornar a diferença dos conjuntos, ele cria um novo conjunto em um determinado destino, contendo a diferença de conjuntos:

      • sdiffstore new_set beatles kings presidents
      • smembers new_set

      Output

      1) "Paul" 2) "Ringo"

      Como o sinterstore, o sdiffstore irá substituir a chave de destino, se ela já existir.

      sunion retorna a união de conjuntos ou um conjunto que contém todos os membros de cada conjunto que você especificar:

      • sunion presidents kings beatles

      Output

      1) "Thomas" 2) "George" 3) "Paul" 4) "Henry" 5) "James" 6) "Edward" 7) "John" 8) "Ringo"

      O sunion trata os resultados como um novo conjunto, em que permite apenas uma ocorrência de qualquer membro.

      O sunionstore executa uma função semelhante, mas cria um novo conjunto contendo a união do conjunto em um determinado destino, em vez de apenas retornar os resultados:

      • sunionstore new_set presidents kings beatles

      Output

      (integer) 8

      Tal como acontece com o sinterstore e o sdiffstore, o sunionstore substituirá a chave de destino, se ela já existir.

      Conclusão

      Este guia detalha vários comandos usados para criar e gerenciar conjuntos no Redis. Se houver outros comandos, argumentos ou procedimentos relacionados que você gostaria de ver descritos neste guia, peça ou faça sugestões nos comentários abaixo.

      Para obter mais informações sobre comandos Redis, consulte nossa série de tutoriais Como Gerenciar um Banco de Dados Redis.



      Source link