Ao usar SQL padrão ou a camada de objetos no InterSystems IRIS, a consistência dos metadados é geralmente mantida por meio de validação integrada e imposição de tipo. No entanto, sistemas legados que ignoram essas camadas—acessando globals diretamente—podem introduzir inconsistências sutis e graves.

Quando precisamos integrar o Caché/IRIS com outros bancos de dados relacionais, uma pergunta comum surge: “Como configuro a conexão JDBC?”. A documentação oficial nem sempre fornece um guia passo a passo direto, o que pode ser frustrante, especialmente para iniciantes.

Neste artigo, vou guiá-lo por todo o processo de configuração de uma conexão JDBC com MySQL, desde o download do conector até o espelhamento de tabelas no Caché/IRIS.

Se você está migrando do Oracle para o InterSystems IRIS — como muitos dos meus clientes — pode se deparar com padrões específicos de SQL do Oracle que precisam ser adaptados.

Veja esse examplo:

SELECT (TO_DATE('2023-05-12','YYYY-MM-DD') - LEVEL + 1) AS gap_date
FROM dual
CONNECT BY LEVEL <= (TO_DATE('2023-05-12','YYYY-MM-DD') - TO_DATE('2023-05-02','YYYY-MM-DD') + 1);

No Oracle:

Devido à interpretação de SCHEMA pelo MySQL diferir do entendimento comum em SQL (como visto em IRIS/SQL Server/Oracle), nosso Assistente de Tabelas Vinculadas automatizado pode encontrar erros ao tentar recuperar informações de metadados para construir a Tabela Vinculada

(Isto também se aplica a Linked Procedures e Views)

Ao tentar criar uma Tabela Vinculada através do Assistente, você encontrará um erro semelhante a este

Pessoal, para consumir dados no caché utilizando uma conexão de uma aplicação java via driver JDBC é necessário realizar alguma configuração adicional no caché?

Não tenho certeza se muitos se conectam ao MS SQL para executar consultas, procedimentos armazenados, etc., mas nosso Sistema de Saúde possui muitos bancos de dados baseados em MS SQL que utilizamos no ambiente de Interoperabilidade por vários motivos.

Com a migração do ambiente local para a nuvem, enfrentamos algumas dificuldades com as conexões do SQL Gateway e como configurá-las para usar o Microsoft Entra para autenticação do Active Directory.

Olá! Eu expandi meu repositório de demonstração, andreas5588/demo-dbs-iris,para facilitar o teste dos recursosFOREIGN SERVER e FOREIGN TABLE no IRIS.

Para alcançar isso, criei um namespace chamado FEDERATION. A ideia é a seguinte:

1. Configurar conexões JDBC para cada namespace.
2. Criar um FOREIGN SERVER dentro do namespace FEDERATION para cada conexão.
3. Definir umaFOREIGN TABLE pelo menos para uma tabela com base em cada servidor externo.

O Script:  demo-dbs-iris/src/sql/02_create_foreign_server.sql

Introdução

Este artigo busca explorar o funcionamento e desenvolvimento do sistema FHIR-PEX, aproveitando os recursos do InterSystems IRIS.

Otimizando a identificação e o processamento de exames médicos nos centros de diagnóstico clínico, nosso sistema visa aumentar a eficiência e precisão dos fluxos de trabalho de saúde. Ao integrar os padrões FHIR ao banco de dados Java-PEX do InterSystems IRIS, o sistema ajuda os profissionais de saúde com recursos de validação e roteamento, melhorando, em última análise, a tomada de decisões e o cuidado dos pacientes.

como funciona

• Interoperabilidade IRIS: Recebe mensagens no padrão FHIR, garantindo a integração e a compatibilidade com os dados da saúde.

• Processamento de informações com "PEX Java": Processa mensagens no formato FHIR e as direciona a tópicos do Kafka com base nas regras configuradas globalmente no banco de dados, possibilitando um processamento e roteamento de dados eficiente, especialmente para exames direcionados à quarentena.

• Tratamento de retornos do Kafka via back-end Java externo: Interpreta apenas os exames direcionados à quarentena, permitindo que o sistema trate os retornos do Kafka por um back-end Java externo. Facilita a geração de insights prognósticos para profissionais da saúde através de IA Generativa, contando com consultas de resultados de exames anteriores dos respectivos pacientes.

Desenvolvimento

Através do PEX (Production EXtension) da InterSystems, ferramenta de extensibilidade que permite aprimoramento e personalização do comportamento do sistema, elaboramos uma Operação de Negócios. Este componente tem a tarefa de processar mensagens recebidas no formato FHIR dentro do sistema. Veja este exemplo:

import com.intersystems.enslib.pex.*;
import com.intersystems.jdbc.IRISObject;
import com.intersystems.jdbc.IRIS;
import com.intersystems.jdbc.IRISList;
import com.intersystems.gateway.GatewayContext;

import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.*;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;

public class KafkaOperation extends BusinessOperation {
// Conexão ao InterSystems IRIS
private IRIS iris;

// Conexão ao Kafka
private Producer<Long, String> producer;

// Endereço do servidor do Kafka (se forem vários, separados por vírgula)
public String SERVERS;

// Nome do nosso Produtor
public String CLIENTID;

/// Caminho para o arquivo Config
public String CONFIG;

public void OnInit() throws Exception {
[...]
}

public void OnTearDown() throws Exception {
[...]
}

public Object OnMessage(Object request) throws Exception {
    IRISObject req = (IRISObject) request;
    LOGINFO("Received object: " + req.invokeString("%ClassName", 1));

    // Crie o registro
    String value = req.getString("Text");
    String topic = getTopicPush(req);
    final ProducerRecord<Long, String> record = new ProducerRecord<>(topic, value);

    // Envie o novo registro
    RecordMetadata metadata = producer.send(record).get();

    // Retorne as informações do regitro
    IRISObject response = (IRISObject)(iris.classMethodObject("Ens.StringContainer","%New",topic+"|"+metadata.offset()));
    return response;
}

private Producer<Long, String> createProducer() throws IOException {
[...]
}

private String getTopicPush(IRISObject req) {
[...]
}

[...]
}

`

Dentro da aplicação, o método getTopicPush assume a responsabilidade de identificar o tópico para o qual a mensagem será enviada.

A determinação do tópico a que a mensagem será enviada depende da existência de uma regra na global "quarantineRule", conforme lido no IRIS.

String code = FHIRcoding.path("code").asText();
String system = FHIRcoding.path("system").asText();

IRISList quarantineRule = iris.getIRISList("quarantineRule",code,system);

 String reference = quarantineRule.getString(1);
 String value = quarantineRule.getString(2);

 String observationValue = fhir.path("valueQuantity").path("value").asText()

Quando há a global ^quarantineRule, a validação do objeto FHIR pode ser validada.

private boolean quarantineValueQuantity(String reference, String value, String observationValue) {
    LOGINFO("quarantine rule reference/value: " + reference + "/" + value);
    double numericValue = Double.parseDouble(value);
    double numericObservationValue = Double.parseDouble(observationValue);

    if ("<".equals(reference)) {
        return numericObservationValue < numericValue;
    }
    else if (">".equals(reference)) {
        return numericObservationValue > numericValue;
    }
    else if ("<=".equals(reference)) {
        return numericObservationValue <= numericValue;
    }
    else if (">=".equals(reference)) {
        return numericObservationValue >= numericValue;
    }
    
    return false;
}

Exemplo prático:

Ao definir uma global, como:

Set ^quarantineRule("59462-2","http://loinc.org") = $LB(">","500") 

Isso estabelece uma regra para o código "59462-2" e o sistema ""http://loinc.org"" na global ^quarantineRule, especificando uma condição em que o valor é definido como quarentena quando ultrapassa 500. No aplicativo, o método getTopicPush pode então usar essa regra para determinar o tópico apropriado para enviar a mensagem com base no resultado da validação.

Dada a atribuição, o JSON abaixo seria enviado para quarentena, porque corresponde à condição especificada por ter:

 {
          "system": "http://loinc.org",
          "code": "59462-2",
          "display": "Testosterone"
}

"valueQuantity": { "value": 550, "unit": "ng/dL", "system": "http://unitsofmeasure.org", "code": "ng/dL" }

Observação FHIR:

{
    "resourceType": "Observation",
    "id": "3a8c7d54-1a2b-4c8f-b54a-3d2a7efc98c9",
    "status": "final",
    "category": [
      {
        "coding": [
          {
            "system": "http://terminology.hl7.org/CodeSystem/observation-category",
            "code": "laboratory",
            "display": "laboratory"
          }
        ]
      }
    ],
    "code": {
      "coding": [
        {
          "system": "http://loinc.org",
          "code": "59462-2",
          "display": "Testosterone"
        }
      ],
      "text": "Testosterone"
    },
    "subject": {
      "reference": "urn:uuid:274f5452-2a39-44c4-a7cb-f36de467762e"
    },
    "encounter": {
      "reference": "urn:uuid:100b4a8f-5c14-4192-a78f-7276abdc4bc3"
    },
    "effectiveDateTime": "2022-05-15T08:45:00+00:00",
    "issued": "2022-05-15T08:45:00.123+00:00",
    "valueQuantity": {
      "value": 550,
      "unit": "ng/dL",
      "system": "http://unitsofmeasure.org",
      "code": "ng/dL"
    }
}

O aplicativo Quarkus Java

Após o envio para o tópico desejado, um aplicativo Quarkus Java foi criado para receber exames em quarentena.

@ApplicationScoped
 public class QuarentineObservationEventListener {

@Inject
PatientService patientService;

@Inject
EventBus eventBus;

@Transactional
@Incoming("observation_quarantine")
public CompletionStage<Void> onIncomingMessage(Message<QuarentineObservation> quarentineObservationMessage) {
	var quarentineObservation = quarentineObservationMessage.getPayload();
	var patientId = quarentineObservation.getSubject()
			.getReference();
	var patient = patientService.addObservation(patientId, quarentineObservation);
	publishSockJsEvent(patient.getId(), quarentineObservation.getCode()
			.getText());
	return quarentineObservationMessage.ack();
}

private void publishSockJsEvent(Long patientId, String text) {
	eventBus.publish("monitor", MonitorEventDto.builder()
			.id(patientId)
			.message(" is on quarentine list by observation ." + text)
			.build());
}
 }

Esse segmento do sistema tem a tarefa de persistir as informações recebidas de Kafka, armazená-las nas observações do paciente no banco de dados e notificar a ocorrência ao monitor.

O monitor

Por fim, o monitor do sistema é responsável por fornecer uma visualização simples do front-end. Isso permite que os profissionais de saúde revisem os dados do paciente/exame e realizem as ações necessárias.

Implementação de langchainPT

Através do monitor, o sistema permite que os profissionais de saúde solicitem recomendações da IA ​​Generativa.

@Unremovable
@Slf4j
@ApplicationScoped
public class PatientRepository {
	@Tool("Get anamnesis information for a given patient id")
	public Patient getAnamenisis(Long patientId) {
		log.info("getAnamenisis called with id " + patientId);
		Patient patient = Patient.findById(patientId);
		return patient;
	}

	@Tool("Get the last clinical results for a given patient id")
	public List<Observation> getObservations(Long patientId) {
		log.info("getObservations called with id " + patientId);
		Patient patient = Patient.findById(patientId);
		return patient.getObservationList();
	}

}

segue implementação de langchain4j

@RegisterAiService(chatMemoryProviderSupplier = RegisterAiService.BeanChatMemoryProviderSupplier.class, tools = {PatientRepository.class})
public interface PatientAI {

	@SystemMessage("""
			You are a health care assistant AI. You have to recommend exams for patients based on history information.
			""")
	@UserMessage("""
			 Your task is to recommend clinical exams for the patient id {patientId}.

			 To complete this task, perform the following actions:
			 1 - Retrieve anamnesis information for patient id {patientId}.
			 2 - Retrieve the last clinical results for patient id {patientId}, using the property 'name' as the name of exam and 'value' as the value.
			 3 - Analyse results against well known conditions of health care.

			 Answer with a **single** JSON document containing:
			 - the patient id in the 'patientId' key
			 - the patient weight in the 'weight' key
			 - the exam recommendation list in the 'recommendations' key, with properties exam, reason and condition.
			 - the 'explanation' key containing an explanation of your answer, especially about well known diseases.

			Your response must be just the raw JSON document, without ```json, ``` or anything else.
			 """)
	String recommendExams(Long patientId);
}

Dessa forma, o sistema pode auxiliar os profissionais de saúde a tomar decisões e realizar ações.

Vídeo de demonstração

VÍDEO

Autores

• Davi Massaru Teixeira Muta
• Flavio Neubauer

OBSERVAÇÃO:

O aplicativo https://openexchange.intersystems.com/package/fhir-pex está participando atualmente do InterSystems Java Contest 2023. Sinta-se à vontade para explorar a solução e não hesite em entrar em contato se tiver alguma dúvida ou precisar de informações adicionais. Recomendamos executar o aplicativo em seu ambiente local para uma experiência prática. Obrigado pela oportunidade 😀!

Com o lançamento do InterSystems IRIS Cloud SQL, estamos recebendo perguntas frequentes sobre como estabelecer conexões seguras por JDBC e outras tecnologias de driver. Temos um ótimo resumo e uma documentação detalhada sobre as tecnologias de driver, mas essa documentação não chega a descrever ferramentas de cliente individuais, como DBeaver, nossa favorita. Neste artigo, vamos descrever as etapas para criar uma conexão segura no DBeaver para sua implantação do Cloud SQL.

Etapa 0: crie sua implantação

Primeiro, faça login no Cloud Services Portal e crie uma implantação do Cloud SQL. Você só precisa se lembrar de marcar a caixa para ativar conexões externas. Tirando isso, todas as configurações padrão devem funcionar bem.

Etapa 1: instale o certificado

Para uma conexão segura, vamos usar certificados para criptografar tudo o que é enviado por ela. Você pode baixar o certificado na página de detalhes da implantação pelo botão "Get X.509 certificate" (Obter certificado X.509):

Em seguida, precisamos armazenar esse certificado em um keystore confiável usando o utilitário keytool. Essa é uma parte padrão da infraestrutura Java, então nada é específico ao IRIS ou ao DBeaver até aqui. Use o comando abaixo para importar o certificado. A localização do arquivo do certificado certificateSQLaaS.pem não importa após executar esse comando, então ele pode ser excluído da pasta de downloads depois. Porém, a localização do arquivo keystore.jks importa. Portanto, execute o comando a partir de uma pasta que faça sentido: onde você continuará a usá-lo para outros fins ou na pasta de instalação do DBeaver, caso seja a única finalidade desse keystore.

keytool -importcert -file path-to-cert/cert-file.pem -keystore keystore.jks

Para mais detalhes, veja a documentação.

Etapa 2: crie um arquivo SSLConfig.properties

Em seguida, precisamos dizer ao driver JDBC do IRIS como encontrar esse keystore, o que é feito através de um arquivo SSLConfig.properties. Esse arquivo de texto simples precisa ser colocado no diretório de trabalho do programa Java que abrirá a conexão JDBC. No Windows, é o %LOCALAPPDATA%\DBeaver, que se traduz em C:\Users\<you>\AppData\Local\DBeaver. No Mac, é geralmente /Applications/DBeaverEE.app/Contents/MacOS. Como alternativa, você também pode criar o arquivo em outro lugar e definir o caminho completo como uma variável de ambiente chamada com.intersystems.SSLConfigFile.

Na sua forma mais simples, esse arquivo só precisa apontar para o keystore e incluir a senha. O caminho do arquivo keystore.jks precisa ter o escape adequado para a leitura pelo Java, então você precisará usar barras invertidas duplas no Windows.

trustStore=/path/to/keystore/keystore.jks
trustStorePassword=keystore-password

Há várias configurações adicionais que você pode definir através desse arquivo descritas na documentação, incluindo configurações do named, mas a indicada acima é suficiente.

Etapa 3: crie sua conexão do DBeaver

Agora que instalamos o certificado e especificamos onde o JDBC do IRIS pode encontrá-lo, podemos criar a conexão do DBeaver. Todas as configurações da guia "Main" no diálogo de criação da conexão podem ser encontradas na tela de detalhes da implementação conforme colada acima:

Só falta dizer para o DBeaver ativar a criptografia definindo o "connection security level" (nível de segurança da conexão) como 10 na guia "Driver properties" (Propriedades do driver):

É isso! Ao clicar em "Test Connection" (Testar conexão), você deve obter um polegar para cima ou uma mensagem de erro útil. No segundo caso, confira esta documentação para solução de problemas se não for óbvio o que deve ser alterado.

Observação para usuários Mac

Se você estiver usando o Mac, parece que há um bug no DBeaver em que o exposto acima pode não ser suficiente. A solução não é convencional, mas funciona. No campo Database/Schema, onde você normalmente colocaria 'USER', insira toda esta string:

USER:sslConnection=true;sslTrustStoreLocation=/pathToTruststore/truststore.jks;sslTrustStorePassword=123456;

Dica e outras sabedorias de @Rick Guidice 
 

Introdução

Este artigo tem como objetivo explorar como o sistema FHIR-PEX funciona e foi desenvolvido, aproveitando os recursos do InterSystems IRIS.

Agilizando a identificação e o processamento de exames médicos em centros de diagnóstico clínico, nosso sistema visa aumentar a eficiência e a precisão dos fluxos de trabalho de saúde. Ao integrar os padrões FHIR com o banco de dados Java-PEX da InterSystems IRIS, o sistema ajuda os profissionais de saúde com recursos de validação e roteamento, contribuindo, em última análise, para melhorar a tomada de decisões e o atendimento ao paciente.

como funciona

• Interoperabilidade IRIS: Recebe mensagens no padrão FHIR, garantindo integração e compatibilidade com dados de saúde.

• Processamento de informações com 'PEX Java': Processa mensagens no formato FHIR e as direciona para tópicos Kafka com base em regras configuradas globalmente no banco de dados, facilitando o processamento e roteamento eficiente de dados, principalmente para exames direcionados à quarentena.

• Tratamento de devoluções Kafka via back-end Java externo: Interpreta apenas os exames direcionados à quarentena, permitindo que o sistema trate os retornos do Kafka por meio de um backend Java externo. Facilita a geração de insights prognósticos para profissionais de saúde através de IA Generativa, contando com consultas de resultados de exames anteriores dos respectivos pacientes.

Desenvolvimento

Através do PEX (Production EXtension) da InterSystems, ferramenta de extensibilidade que permite aprimoramento e customização do comportamento do sistema, elaboramos uma Operação de Negócio. Este componente tem a tarefa de processar mensagens recebidas no formato FHIR dentro do sistema.

Segue exemplo:

    import com.intersystems.enslib.pex.;     import com.intersystems.jdbc.IRISObject;     import com.intersystems.jdbc.IRIS;     import com.intersystems.jdbc.IRISList;     import com.intersystems.gateway.GatewayContext;          import org.apache.kafka.clients.producer.;     import org.apache.kafka.common.serialization.*;          import com.fasterxml.jackson.databind.JsonNode;     import com.fasterxml.jackson.databind.ObjectMapper;          import java.io.FileInputStream;     import java.io.IOException;     import java.util.Properties;

    public class KafkaOperation extends BusinessOperation {     // Connection to InterSystems IRIS     private IRIS iris;          // Connection to Kafka     private Producer<Long, String> producer;          // Kafka server address (comma separated if several)     public String SERVERS;          // Name of our Producer     public String CLIENTID;          /// Path to Config File     public String CONFIG;          public void OnInit() throws Exception {     [...]     }          public void OnTearDown() throws Exception {     [...]     }          public Object OnMessage(Object request) throws Exception {         IRISObject req = (IRISObject) request;         LOGINFO("Received object: " + req.invokeString("%ClassName", 1));              // Create record         String value = req.getString("Text");         String topic = getTopicPush(req);         final ProducerRecord<Long, String> record = new ProducerRecord<>(topic, value);              // Send new record         RecordMetadata metadata = producer.send(record).get();              // Return record info         IRISObject response = (IRISObject)(iris.classMethodObject("Ens.StringContainer","%New",topic+"|"+metadata.offset()));         return response;     }          private Producer<Long, String> createProducer() throws IOException {     [...]     }          private String getTopicPush(IRISObject req) {     [...]     }          [...]     } `

Dentro da aplicação, o método getTopicPush assume a responsabilidade de identificar o tópico para o qual a mensagem será enviada.

A determinação para qual tópico a mensagem será enviada depende da existência de uma regra na “quarantineRule” global, conforme lida dentro do IRIS.

    String code = FHIRcoding.path("code").asText();     String system = FHIRcoding.path("system").asText();

    IRISList quarantineRule = iris.getIRISList("quarantineRule",code,system);

     String reference = quarantineRule.getString(1);      String value = quarantineRule.getString(2);

     String observationValue = fhir.path("valueQuantity").path("value").asText()

Quando o ^quarantineRule global existe, a validação do objeto FHIR pode ser validada.

    private boolean quarantineValueQuantity(String reference, String value, String observationValue) {         LOGINFO("quarantine rule reference/value: " + reference + "/" + value);         double numericValue = Double.parseDouble(value);         double numericObservationValue = Double.parseDouble(observationValue);

        if ("<".equals(reference)) {             return numericObservationValue < numericValue;         }         else if (">".equals(reference)) {             return numericObservationValue > numericValue;         }         else if ("<=".equals(reference)) {             return numericObservationValue <= numericValue;         }         else if (">=".equals(reference)) {             return numericObservationValue >= numericValue;         }                  return false;     }

Exemplo prático:

Ao definir um global, como:

    Set ^quarantineRule("59462-2","http://loinc.org") = $LB(">","500") 

Isso estabelece uma regra para o código "59462-2" e o sistema ""http://loinc.org"" na ^quarantineRule global, especificando uma condição onde o valor quando maior que 500 é definido como quarentena. No aplicativo, o método getTopicPush pode então usar essa regra para determinar o tópico apropriado para enviar a mensagem com base no resultado da validação.

Dada a atribuição, o JSON abaixo seria enviado para quarentena, pois corresponde à condição especificada por ter:

 {
          "system": "http://loinc.org",
          "code": "59462-2",
          "display": "Testosterone"
}

"valueQuantity": { "value": 550, "unit": "ng/dL", "system": "http://unitsofmeasure.org", "code": "ng/dL" }

FHIR Observation:

{
    "resourceType": "Observation",
    "id": "3a8c7d54-1a2b-4c8f-b54a-3d2a7efc98c9",
    "status": "final",
    "category": [
      {
        "coding": [
          {
            "system": "http://terminology.hl7.org/CodeSystem/observation-category",
            "code": "laboratory",
            "display": "laboratory"
          }
        ]
      }
    ],
    "code": {
      "coding": [
        {
          "system": "http://loinc.org",
          "code": "59462-2",
          "display": "Testosterone"
        }
      ],
      "text": "Testosterone"
    },
    "subject": {
      "reference": "urn:uuid:274f5452-2a39-44c4-a7cb-f36de467762e"
    },
    "encounter": {
      "reference": "urn:uuid:100b4a8f-5c14-4192-a78f-7276abdc4bc3"
    },
    "effectiveDateTime": "2022-05-15T08:45:00+00:00",
    "issued": "2022-05-15T08:45:00.123+00:00",
    "valueQuantity": {
      "value": 550,
      "unit": "ng/dL",
      "system": "http://unitsofmeasure.org",
      "code": "ng/dL"
    }
}

### Quarkus Java application

Após o envio para o tópico desejado, foi construída uma aplicação Quarkus Java para recebimento de exames em quarentena.

    @ApplicationScoped      public class QuarentineObservationEventListener {

    @Inject     PatientService patientService;

    @Inject     EventBus eventBus;

    @Transactional     @Incoming("observation_quarantine")     public CompletionStage<Void> onIncomingMessage(Message<QuarentineObservation> quarentineObservationMessage) {         var quarentineObservation = quarentineObservationMessage.getPayload();         var patientId = quarentineObservation.getSubject()                 .getReference();         var patient = patientService.addObservation(patientId, quarentineObservation);         publishSockJsEvent(patient.getId(), quarentineObservation.getCode()                 .getText());         return quarentineObservationMessage.ack();     }

    private void publishSockJsEvent(Long patientId, String text) {         eventBus.publish("monitor", MonitorEventDto.builder()                 .id(patientId)                 .message(" is on quarentine list by observation ." + text)                 .build());     }      }

Este segmento do sistema tem a tarefa de persistir as informações recebidas de Kafka, armazená-las nas observações do paciente no banco de dados e notificar a ocorrência ao monitor.

O monitor

Por fim, o monitor do sistema é responsável por fornecer uma visualização simples do front-end. Isso permite que os profissionais de saúde revisem os dados do paciente/exame e tomem as ações necessárias.

Implementação of langchain

Através do monitor, o sistema permite que os profissionais de saúde solicitem recomendações da IA ​​Generativa.

    @Unremovable     @Slf4j     @ApplicationScoped     public class PatientRepository {         @Tool("Get anamnesis information for a given patient id")         public Patient getAnamenisis(Long patientId) {             log.info("getAnamenisis called with id " + patientId);             Patient patient = Patient.findById(patientId);             return patient;         }              @Tool("Get the last clinical results for a given patient id")         public List<Observation> getObservations(Long patientId) {             log.info("getObservations called with id " + patientId);             Patient patient = Patient.findById(patientId);             return patient.getObservationList();         }          }

segue implementação de langchain4j

    @RegisterAiService(chatMemoryProviderSupplier = RegisterAiService.BeanChatMemoryProviderSupplier.class, tools = {PatientRepository.class})     public interface PatientAI {              @SystemMessage("""                 You are a health care assistant AI. You have to recommend exams for patients based on history information.                 """)         @UserMessage("""                  Your task is to recommend clinical exams for the patient id {patientId}.                       To complete this task, perform the following actions:                  1 - Retrieve anamnesis information for patient id {patientId}.                  2 - Retrieve the last clinical results for patient id {patientId}, using the property 'name' as the name of exam and 'value' as the value.                  3 - Analyse results against well known conditions of health care.                       Answer with a single JSON document containing:                  - the patient id in the 'patientId' key                  - the patient weight in the 'weight' key                  - the exam recommendation list in the 'recommendations' key, with properties exam, reason and condition.                  - the 'explanation' key containing an explanation of your answer, especially about well known diseases.                      Your response must be just the raw JSON document, without json, or anything else.                  """)         String recommendExams(Long patientId);     }

Dessa forma, o sistema pode auxiliar os profissionais de saúde na tomada de decisões e na execução de ações.

Video demonstração 

VIDEO

Autores

• Davi Massaru Teixeira Muta
• Flavio Neubauer

NOTA: 

O aplicativo https://openexchange.intersystems.com/package/fhir-pex está participando atualmente do InterSystems Java Contest 2023. Sinta-se à vontade para explorar a solução e não hesite em entrar em contato se tiver alguma dúvida ou precisar de informações adicionais. Recomendamos executar o aplicativo em seu ambiente local para uma experiência prática. Obrigado pela oportunidade 😀!

Artigo original: https://community.intersystems.com/post/sending-kafka-messages-java-pex-processing-quarantine-exam-prognoses

Estou utilizando JDBC para conexão da aplicação JAVA com o IRIS versão Community, porém está ocorrendo o seguinte erro:

Caused by: java.sql.SQLException: [InterSystems IRIS JDBC] Communication link failure: Acesso Negado
    at com.intersystems.jdbc.IRISConnection.connect(IRISConnection.java:751)
    at com.intersystems.jdbc.IRISConnection.<init>(IRISConnection.java:165)
    at com.intersystems.jdbc.IRISDriver.connect(IRISDriver.java:58)
    ... 46 more

Ao verificar o relatório de auditoria do banco IRIS verifiquei o seguinte log de erro:

WIN SQL é o editor usado pela maioria dos usuários. No entanto, não é possível fazer o download de grandes quantidades de dados usando o winsql . Então, escrevi um tutorial sobre como fazer a conexão com um novo editor baseado em Java chamado Squirrel SQL, que permite fazer o download ou exportar dados facilmente em excel ou qualquer outro formato. Também incluí um programa de conexão JDBC do Java para se conectar com um banco de dados do IRIS, particularmente um servidor de espelhamento/tolerante a falhas.

Editor SQL baseado em Java para exportar uma grande quantidade de dados e programa JDBC Java para a conexão com o IRIS

Editor SQL baseado em Java para exportar uma grande quantidade de dados

O WinSql é o editor normalmente usado para extrair dados do banco de dados do IRIS. Porém, infelizmente, não há a opção de exportar uma grande quantidade de dados sem o winsql licenciado.

A solução é usar um editor baseado em Java, chamado Squirrel SQL. Nesse editor, você pode exportar uma grande quantidade de dados depois de fazer o fetch do sql no banco de dados do IRIS. É um cliente SQL de código aberto criado no Java, que usa o JDBC para a conexão com o banco de dados do IRIS.

Recursos do Squirrel SQL

Etapas para instalar o Squirrel SQL

O Squirrel SQL pode ser baixado no site Squirrel https://squirrel-sql.sourceforge.io/

Etapas para se conectar a um banco de dados do IRIS

 C:\InterSystems\IRISHealth2\dev\java\lib\JDK18\intersystems-jdbc-3.2.0.jar.

2. Adicionando um alias (conexão) baseado no driver

Por exemplo : jdbc:IRIS://00.00.00.00.00:12345/TEST-TRAK

3. Conexão ao banco de dados do IRIS

Conexão do JDBC ao banco de dados do IRIS para escrever programas

import java.sql.*;
import com.intersystems.jdbc.*;
import java.util.logging.*;
import java.io.IOException;
import java.util.*;

publicclassExtract{
    publicstatic Connection TrakCache()throws Exception
    {
             IRISDataSource ds = new IRISDataSource();
             Connection conn = null;

             ds.setURL("jdbc:IRIS://1.12.333.444:12345/NAMESPACE-TRAK");
             ds.setUser("username");
             ds.setPassword("Password");

              try
              {
                        conn = ds.getConnection();
              }
              catch (Exception e) {
                System.out.println("catch" +conn);
                //You can write another connection here if automatically fail over to another server.
              }
              return conn;
    }
}

Olá Comunidade, 

Assista a este vídeo para ver como se conectar ao InterSystems Cloud Services a partir de seu aplicativo Java usando o driver InterSystems JDBC:

⏯ Connecting to InterSystems Cloud Services with Java

Fala pessoal!!!

Finalmente consegui um tempinho para organizar um conjunto de classes que venho utilizando alguns anos para facilitar e acabar com o trabalho repetitivo no desenvolvimento de intragrações utilizando XDBC.

Acessem o repositório do projeto no https://github.com/cristianojs/interopway

A idéia é incrementar o projeto com mais componentes, já tenho um que a massa está crescendo e jajá vai para o forno.

Quaisquer dúvidas postem aqui.

Grande abraço.

Olá desenvolvedores,

Divirtam-se assistindo o novo vídeo no InterSystems Developers YouTube:

⏯ InterSystems IRIS Cloud SQL @ Global Summit 2022

Olá,

Segundo a Wikipedia:

O KNIME é uma plataforma livre e de código aberto de análise de dados, construção de relatórios e integração de dados. O KNIME integra vários componentes para aprendizado de máquina e mineração de dados por meio de seu conceito de pipelining modular.

Uma interface gráfica de usuário e o uso de JDBC permitem a montagem de nós combinando diferentes fontes de dados, incluindo pré-processamento (ETL: Extract, transform, load), para modelagem, análise e visualização de dados sem necessidade (ou com necessidade mínima) de programação.

Boa tarde à todos!

Preciso fazer uma chamada sql (utilizando JDBC) para executar uma procedure que retorna um objeto estruturado (Oracle Object) como parâmetro de saída.

No entanto, o método do Adptador SQL não está aceitando o tipo de dado STRUCT do JDBC (referente ao Oracle Oject), retornando a seguinte mensagem de erro:

ERRO #5023: Erro no Gateway Remoto: JDBC Gateway SP execute(0) error 0: Remote JDBC error: ORA-06550: line 1, column 7:
PLS-00306: wrong number or types of arguments in call to 'AGUARDAR_EVENTO'
ORA-06550: line 1, column 7:
PL/SQL: Statement ignored

Pessoal,

Procuro perfil de analista de integração / Ensemble (freelance). Interessados, por favor enviar mensagem de WhatsApp (61) 98405-2981.

Local de trabalho: 100% Remoto

Habilidades:  Cache DB, Object Script, InterSystems, Ensemble

Conhecimentos Necessários: