À medida que os dados se tornam mais críticos para os negócios, a necessidade de processamento de dados em tempo real (principalmente quando os dados chegam em blocos ou fluxos) e análise aumenta a uma taxa sem precedentes. Os aplicativos que dependem do processamento de dados em tempo real exigem um método confiável de recebimento de notificações em tempo real quando ocorrem alterações de dados sem causar sobrecargas de desempenho resultantes da sondagem manual, especificamente ao trabalhar com grandes conjuntos de dados. Para resolver essas questões, NCache fornece sua Consulta Contínua recurso – onde você pode criar consultas que filtram dados de acordo com seus critérios definidos.
Sem o incômodo da pesquisa manual, o CQ permite que os desenvolvedores rastreiem as alterações de dados em tempo real e recebam alertas. Por exemplo, em um aplicativo de negociação de ações em tempo real, os traders precisam de atualizações constantes sobre as mudanças nos preços das ações. Sem um sistema de monitoramento em tempo real adequado, eles teriam que verificar manualmente os preços das ações – resultando em perda de tempo e perda de oportunidades. Os traders podem, portanto, criar consultas que filtram os preços das ações para receber atualizações em tempo real sempre que os dados filtrados mudarem. Isso lhes dá a vantagem de consultar o cache apenas para o conjunto de dados de sua escolha (usando Consultas OQL semelhantes a SQL) dentro do cluster de cache distribuído em vez de esgotar o cache. Este blog irá guiá-lo através do uso da Consulta Contínua para monitorar alterações de dados em NCache usando Python.
Monitorando Mudanças Através de Consulta Contínua em NCache
Com o NCacheCom o recurso Continuous Query do, você pode definir um conjunto de dados específico na rede de cache distribuído e rastrear alterações usando consultas OQL. Quando alterar ocorrem dentro do conjunto de dados (devido a operações de gravação como adicionar, atualizar ou remover operações), os aplicativos registrados são atualizados por meio de Eventos de nível de cache, que evita a sobreposição de aplicativos filtrando dados usando consultas OQL. Ao fornecer um método para rastrear e compartilhar dados entre aplicativos por meio de eventos, o CQ permite que os desenvolvedores especifiquem sua lógica de negócios.
Ao usar CQ em Python, os usuários podem aproveitar o NCache Python Client Library para registrar eventos CQ. Você também pode especificar a quantidade de dados retornados na execução do evento, ou seja, nenhum, metadadosou Dados com Metadados. No entanto, é essencial entender que a Consulta Contínua atua apenas como um mecanismo de monitoramento de alterações, e não como alteração de dados do aplicativo.
Configurando a Consulta Contínua em NCache
As etapas mencionadas abaixo explicam o processo de registrar e cancelar o registro de callbacks, consultas e notificações para receber notificações no conjunto de dados definido por você.
Etapa 1: registrar retorno de chamada para eventos
Primeiro, você precisa registrar um callback para Cache Level Events, pode ser Add, Update, Remove ou uma combinação, para que esses callbacks sejam executados sempre que a consulta for modificada. O código de exemplo abaixo mostra como registrar um retorno de chamada para um evento ITEM_ADDED.
1 2 3 4 |
def query_item_callback(key: str, arg: ncache.CQEventArg): if arg.get_event_type() is ncache.EventType.ITEM_ADDED: # Key has been added to the cache print(key + " added to cache") |
Você também pode registrar eventos de retorno de chamada para itens atualizados e eventos removidos.
- NCache Adicionar ao carrinho
- Registrando retorno de chamada para eventos
- Registrando retorno de chamada para eventos
Etapa 2: registrar consulta e notificações
Os principais processos para rastrear alterações de dados em NCache estão registrando retornos de chamada e criando uma Consulta Contínua que especifica os critérios do conjunto de resultados. Após a criação da consulta, os callbacks pré-definidos são registrados com base em Eventtype e EventDataFilter. A seguir, o execute_reader é usado para consultar dados em cache depois que o CQ foi registrado no servidor usando registrar_cq. Para acionar eventos, os dados do cache podem ser modificados para afetar o conjunto de resultados. O código de exemplo abaixo demonstra esse cenário.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 |
# Precondition: Cache is already connected # Query for required operation query = "SELECT $Value$ FROM FQN.Product WHERE category = ?" query_command = ncache.QueryCommand(query) query_command.set_parameters({"Category": "Beverages"}) # Create continuous query continuous_query = ncache.ContinuousQuery(query_command) event_type = [ncache.EventType.ITEM_REMOVED] # Item remove notification # EventDataFilter.Metadata returns cache keys + item metadata on updation continuous_query.add_data_modification_listener(cq_event_listener, event_type, ncache.EventDataFilter.NONE) # Register continuous query on server cache.get_messaging_service().register_cq(continuous_query) reader = cache.get_search_service().execute_reader(query_command) if reader.get_field_count() > 0: while reader.read(): result = reader.get_value(Product, 1) # Perform operations else: # None query result set returned print("Query result is None") # Update Product data in cache to trigger callback updated_product = Product() updated_product.set_product_id(1001) updated_product.set_product_name("Tea") key = "Product:" + updated_product.get_product_id() cache_item = ncache.CacheItem(updated_product) # Trigger add notifications version = cache.insert(key, cache_item) # This will add item to the result set as it matches query criteria |
Etapa 3: cancelar o registro de notificações da consulta contínua
Para deixar de receber notificações da Consulta Contínua em sua aplicação, você tem a opção de descadastrar através do remove_data_modification_listener método. No entanto, isso é específico para os tipos de evento como Adicionar e Remover. Você pode até mesmo cancelar o registro das notificações de itens adicionados se, anteriormente, você se registrou para ambos os eventos de itens adicionados e removidos, mas agora requer apenas notificações para o item removido.
1 2 3 |
# Unregister notifications for ItemAdded events only event_type = [ncache.EventType.ITEM_ADDED] c_query.remove_data_modification_listener(cq_event_listener, event_type) |
Etapa 4: cancelar o registro da consulta contínua do servidor
Para evitar a utilização de recursos quando esta consulta não for mais necessária, você deve cancelar o registro da Consulta Contínua do servidor. Ao fazer isso, você não receberá mais notificações sobre alterações no conjunto de resultados da consulta. O exemplo de código a seguir mostra como cancelar o registro de CQ do servidor de cache usando o un_register_cq método.
1 2 |
# Unregister cq from server cache.get_messaging_service().un_register_cq(c_query) |
Conclusão
Com o NCacheCom o recurso Continuous Query, você pode monitorar alterações em um conjunto de dados específico dentro de um cluster de cache distribuído. Ele garante que apenas os dados necessários sejam recuperados pelo aplicativo, melhorando a eficiência e minimizando o processamento de dados estranhos por meio de consultas OQL e eventos de nível de cache. Uma maneira tão fácil e flexível de monitorar mudanças? Comece seu teste gratuito hoje!