#SQL

Hola comunidad,

Quería compartir mi experiencia trabajando en proyectos con grandes volúmenes de datos. A lo largo de los años, he tenido la oportunidad de manejar enormes cantidades de datos de pacientes, datos de aseguradoras y registros transaccionales mientras trabajaba en la industria hospitalaria. He tenido la oportunidad de crear informes muy extensos que requerían usar lógicas avanzadas para obtener datos de múltiples tablas, cuyos índices no me ayudaban a escribir un código eficiente.

Esto es lo que he aprendido sobre cómo gestionar grandes volúmenes de datos de manera eficiente.

Elegir el método de acceso a datos adecuado

Como todos sabemos en esta comunidad, IRIS ofrece múltiples formas de acceder a los datos. Elegir el método correcto dependerá de lo que necesitemos.

• Acceso directo a los Globales: el más rápido para operaciones masivas de lectura/escritura. Por ejemplo, si tengo que recorrer índices y obtener datos de pacientes, puedo iterar sobre los globales para procesar millones de registros. Esto ahorra mucho tiempo.

Set ToDate=+HSet FromDate=+$H-1ForSet FromDate=$O(^PatientD("Date",FromDate)) Quit:FromDate>ToDate  Do
. Set PatId=""ForSet PatId=$Order(^PatientD("Date",FromDate,PatID)) Quit:PatId=""Do
. . Write$Get(^PatientD("Date",FromDate,PatID)),!

• Uso de SQL: útil para requisitos de generación de informes o análisis, aunque más lento para conjuntos de datos muy grandes.

Tuve el mismo problema que contaba Jerry en el siguiente enlace al conectar IRIS con el servidor SQL. Mi conexión ODBC está configurada para autenticarse mediante autenticación nativa de Windows.

Configurad la conexión ODBC de IRIS con autenticación de Windows utilizando una cuenta de dominio específica en lugar de la cuenta predeterminada del servidor IRIS

¿Cómo lo solucioné yo?

La raíz del problema

Me uní a InterSystems hace menos de un año. Sumergirme en ObjectScript e IRIS fue emocionante, pero también estuvo lleno de pequeñas sorpresas que me hicieron tropezar al principio. En este artículo recojo los errores más comunes que yo, y muchos compañeros nuevos, cometemos, explico por qué ocurren y muestro ejemplos concretos junto con soluciones prácticas. Mi objetivo es ayudar a otros desarrolladores que empiezan a ahorrar tiempo y evitar los mismos obstáculos en el camino.

1. Perderse entre las clases del sistema y no saber por dónde empezar

¡Hola a todos!

Es muy fácil importar datos CSV en IRIS. Pero, ¿qué pasa si queremos preservar los IDs originales del CSV?

Recientemente me encontré con la situación en la que necesitaba importar dos CSVs en IRIS que estaban vinculados por una columna que hacía referencia a la columna de otro CSV: una situación típica de clave primaria y clave externa, donde csv1 contiene esta columna como clave primaria, y csv2 como clave externa con IDs relacionados con csv1.

La imagen fue generada por ChatGPT, así que no lo culpéis: hizo lo mejor que pudo al generar países como claves primarias con una relación countries.csv–cities.csv :)

Algo que he aprendido a lo largo de los años es que, por muy pulida que esté vuestra lógica de aplicación, el rendimiento de la base de datos acabará haciendo o deshaciendo la experiencia de usuario. Trabajando con InterSystems IRIS, recientemente me topé con esto de primera mano. Un cliente nuestro estaba construyendo un panel de informes que funcionaba a la perfección en las pruebas, pero cuando el conjunto de datos de producción creció hasta millones de registros, los tiempos de respuesta se arrastraban.

En el artículo anterior vimos cómo construir un agente de IA de atención al cliente con smolagents e InterSystems IRIS, combinando SQL, RAG con búsquedas vectoriales e interoperabilidad.

En ese caso, utilizamos modelos en la nube (OpenAI) para el LLM y los embeddings.

En esta ocasión daremos un paso más: ejecutar el mismo agente, pero con modelos locales gracias a Ollama.

¿Por qué ejecutar modelos en local?

El uso de LLMs en la nube es la opción más sencilla para empezar:

• ✅ Modelos ya optimizados y mantenidos
• ✅ Fácil acceso con una simple API
• ✅ Servicio serverless: no necesitas preocuparte por el hardware ni mantenimiento
• ❌ Costes por uso
• ❌ Dependencia de servicios externos
• ❌ Restricciones de privacidad al enviar datos

En cambio, al correr modelos en local conseguimos:

• ✅ Control total sobre los datos y el entorno
• ✅ Sin costes variables por uso
• ✅ Posibilidad de hacer fine tuning o adaptar modelos con técnicas como LoRA (Low-Rank Adaptation), que permite entrenar algunas capas del modelo para ajustarlo a tu dominio concreto sin necesidad de reentrenarlo entero
• ❌ Mayor consumo de recursos en tu servidor
• ❌ Limitaciones en tamaño/modelos dependiendo del hardware

Ahí es donde entra en juego Ollama.

¿Qué es Ollama?

Ollama es una herramienta que facilita la ejecución de modelos de lenguaje y embeddings en tu propio ordenador con una experiencia muy simple:

• Descargas modelos con un ollama pull
• Los ejecutas de forma local, expuestos como una API HTTP
• Los puedes integrar directamente en tus aplicaciones, igual que harías con OpenAI

En resumen: la misma API que usarías en la nube, pero corriendo en tu portátil o servidor.

Configuración básica de Ollama

Primero, instala Ollama desde su web y verifica que funciona:

ollama --version

Después, descarga un par de modelos:

# Descargar un modelo de embeddings
ollama pull nomic-embed-text:latest

# Descargar un modelo de lenguaje
ollama pull llama3.1:8b

# Ver todos los modelos disponibles
ollama list

Puedes probar embeddings directamente con un curl:

curl http://localhost:11434/api/embeddings -d '{
  "model": "nomic-embed-text:latest",
  "prompt": "Ollama hace sencillo ejecutar LLMs en local."
}'

Usar Ollama en el agente de IRIS

El repositorio Customer Support Agent Demo incluye ya la configuración para Ollama. Sólo necesitas:

1. Descargar los modelos necesarios para ejecutarlos en Ollama Yo he utilizado nomic-embed-text para los embeddings de las búsquedas vectoriales y devstral como LLM.

2. Configurar IRIS para utilizar embeddings de Ollama con el modelo local:

INSERT INTO %Embedding.Config (Name, Configuration, EmbeddingClass, VectorLength, Description)
  VALUES ('ollama-nomic-config', 
          '{"apiBase":"http://host.docker.internal:11434/api/embeddings", 
            "modelName": "nomic-embed-text:latest"}',
          'Embedding.Ollama', 
          768,  
          'embedding model in Ollama');

3. Ajustar el tamaño de las columnas para almacenar vectores en las tablas del ejemplo (el modelo local tiene un tamaño diferente de vectores que el de OpenAI original).

ALTER TABLE Agent_Data.Products DROP COLUMN Embedding;
ALTER TABLE Agent_Data.Products ADD COLUMN Embedding VECTOR(FLOAT, 768);

ALTER TABLE Agent_Data.DocChunks DROP COLUMN Embedding;
ALTER TABLE Agent_Data.DocChunks ADD COLUMN Embedding VECTOR(FLOAT, 768);

4. Configurar el fichero de entorno .env para indicar los modelos que queremos utilizar:

OPENAI_MODEL=devstral:24b-small-2505-q4_K_M
OPENAI_API_BASE=http://localhost:11434/v1
EMBEDDING_CONFIG_NAME=ollama-nomic-config

5. Actualizar los embeddings

Como tenemos un modelo de embedding diferente del original, debemos actualizar los embeddings utilizando el modelo local nomic-embed-text

python scripts/embed_sql.py

6. Ejecutar el agente para que haga uso de la nueva configuración

El código ya utilizará la configuración para que tanto los embeddings como el LLM se sirvan desde el endpoint local.

Con esta configuración podrás hacer preguntas como:

• “¿Dónde está mi pedido #1001?”
• “¿Cuál es el plazo de devolución?"

Y el agente utilizará:

• SQL de IRIS para datos estructurados
• Búsquedas vectoriales con embeddings de Ollama (local)
• Interoperabilidad para simular llamadas a APIs externas
• Un LLM local para planificar y generar código que llame a las herramientas necesarias para obtener la respuesta

Conclusión

Gracias a Ollama, podemos ejecutar nuestro Agente de Atención al Cliente con IRIS sin depender de la nube:

• Privacidad y control de los datos
• Coste cero por token
• Flexibilidad total para probar y adaptar modelos (LoRA)

¿El reto? Necesitas una máquina con suficiente memoria y CPU/GPU para correr modelos grandes. Pero para prototipos y pruebas, es una opción muy potente y práctica.

Referencias útiles

• 📖 Documentación oficial de Ollama: https://ollama.com

• 📦 Lista de modelos disponibles en Ollama: https://ollama.com/library

• 🧩 Introducción a LoRA para adaptar modelos grandes de forma eficiente:

  • Explicación sencilla: https://huggingface.co/docs/peft/main/en/conceptual_guides/lora

Las preguntas de atención al cliente pueden abarcar datos estructurados (pedidos, productos 🗃️), conocimiento no estructurado (docs/FAQs 📚) y otros sistemas integrados (actualizaciones de envío 🚚). En este post vamos a construir un agente de IA compacto que cubre los tres—usando:

• 🧠 Python + smolagents para orquestar el “cerebro” del agente
• 🧰 InterSystems IRIS para SQL, Búsqueda Semántica (RAG) e Interoperabilidad (una API de seguimiento de envío simulada)

⚡ TL;DR (versión express)

• Construye un Agente de Atención al Cliente funcional con Python + smolagents orquestando herramientas sobre InterSystems IRIS (SQL, Búsqueda Semántica/RAG, Interoperabilidad con una API simulada).
• Responde preguntas reales (p. ej., “¿Se entregó el pedido #1001?”“¿Cuál es el plazo de devolución?”) combinando tablas, documentos y llamadas de interoperabilidad.
• Inicia IRIS en Docker, carga el esquema y datos de ejemplo, prepara los embeddings de los documentos para RAG, registra herramientas (SQL/RAG/API) y ejecuta el agente por línea de comando o interfaz gráfica.

🧭 Lo que vas a construir

Un Agente de Atención al Cliente capaz de:

• 🔎 Consultar datos estructurados (clientes, pedidos, productos, envíos) vía SQL
• 📚 Recuperar conocimiento no estructurado (FAQs y documentos) con RAG sobre IRIS Vector Search (Búsqueda Vectorial)
• 🔌 Llamar a una API de seguimiento envío (simulada) mediante el framework de Interoperabilidad de IRIS, con Visual Trace para inspeccionar cada llamada

Arquitectura (resumida)

Usuario ➜ Agente (smolagents CodeAgent)
               ├─ Herramienta SQL ➜ Tablas en IRIS
               ├─ Herramienta RAG ➜ Búsqueda Vectorial en IRIS (embeddings + chunks)
               └─ Herramienta Seguimiento Envío ➜ Interoperabilidad IRIS (simulada) ➜ Visual Trace

¿Conoces smolagents? Es un framework ligero de agentes de Hugging Face en el que el modelo planifica y utiliza tus herramientas; como alternativas, puedes considerar LangGraph y LlamaIndex.

🧱 Prerrequisitos

• 🐍 Python 3.9+
• 🐳 Docker para ejecutar IRIS en un contenedor
• 🧑‍💻 VS Code para revisar el código
• 🔑 Clave de API de OpenAI (para el LLM y los embeddings) — o ejecútalo localmente con Ollama si lo prefieres

1) 🧩 Clona el repositorio y prepara un entorno Python

git clone https://github.com/intersystems-ib/customer-support-agent-demo
cd customer-support-agent-demo

python -m venv .venv
# macOS/Linux
source .venv/bin/activate
# Windows (PowerShell)
# .venv\Scripts\Activate.ps1

pip install -r requirements.txt
cp .env.example .env   # añade tu clave de OpenAI

2) 🐳 Arranca InterSystems IRIS (Docker)

docker compose build
docker compose up -d

Abre el Management Portal (http://localhost:52773 en esta demo).

3) 🗃️ Carga los datos estructurados (SQL)

Desde el SQL Explorer de IRIS o tu cliente SQL favorito:

LOAD SQL FROM FILE '/app/iris/sql/schema.sql' DIALECT 'IRIS' DELIMITER ';';
LOAD SQL FROM FILE '/app/iris/sql/load_data.sql' DIALECT 'IRIS' DELIMITER ';';

Este es el esquema que acabas de cargar:

Ejecuta algunas consultas para familiarizarte con los datos. El agente usará estas tablas para resolver preguntas:

-- Listado de clientes
SELECT * FROM Agent_Data.Customers;

-- Pedidos de un cliente
SELECT o.OrderID, o.OrderDate, o.Status, p.Name AS Product
FROM Agent_Data.Orders o
JOIN Agent_Data.Products p ON o.ProductID = p.ProductID
WHERE o.CustomerID = 1;

-- Info de envío de un pedido
SELECT * FROM Agent_Data.Shipments WHERE OrderID = 1001;

✅ Si ves filas, tu parte estructurada está lista.

4) 📚 Añade conocimiento no estructurado con Vector Search (RAG)

Crea una configuración de embeddings (el ejemplo usa un modelo de OpenAI; ajústalo a tu gusto):

INSERT INTO %Embedding.Config
  (Name, Configuration, EmbeddingClass, VectorLength, Description)
VALUES
  ('my-openai-config',
   '{"apiKey":"YOUR_OPENAI_KEY","sslConfig":"llm_ssl","modelName":"text-embedding-3-small"}',
   '%Embedding.OpenAI',
   1536,
   'a small embedding model provided by OpenAI');

¿Quieres los pasos y opciones exactos? Consulta la documentación

Después, genera los embeddings del contenido de ejemplo:

python scripts/embed_sql.py

Comprueba que los embeddings están en las tablas:

SELECT COUNT(*) AS ProductChunks FROM Agent_Data.Products;
SELECT COUNT(*) AS DocChunks     FROM Agent_Data.DocChunks;

🔎 Bonus: Búsqueda híbrida + vectorial directamente desde SQL con EMBEDDING()

Una gran ventaja de IRIS es que puedes hacer búsqueda semántica (vectorial) dentro de SQL y mezclarla con filtros clásicos—sin microservicios extra. La función EMBEDDING() de SQL crea al vuelo el vector de tu texto de búsqueda y puedes compararlo con vectores almacenados usando operaciones como VECTOR_DOT_PRODUCT.

Ejemplo A — Búsqueda híbrida de productos (filtro por precio + ranking semántico):

SELECT TOP 3
    p.ProductID,
    p.Name,
    p.Category,
    p.Price,
    VECTOR_DOT_PRODUCT(p.Embedding, EMBEDDING('headphones with ANC', 'my-openai-config')) score
FROM Agent_Data.Products p
WHERE p.Price < 200
ORDER BY score DESC

Ejemplo B — Búsqueda semántica de fragmentos de documentos (ideal para alimentar RAG):

SELECT TOP 3
    c.ChunkID  AS chunk_id,
    c.DocID      AS doc_id,
    c.Title         AS title,
    SUBSTRING(c.ChunkText, 1, 400) AS snippet,
    VECTOR_DOT_PRODUCT(c.Embedding, EMBEDDING('warranty coverage', 'my-openai-config')) AS score
FROM Agent_Data.DocChunks c
ORDER BY score DESC

¿Por qué es potente? Puedes pre-filtrar por precio, categoría, idioma, tenant, fechas, etc., y luego ordenar por similitud semántica—todo en una sola sentencia SQL.

5) 🔌 Conecta una API de envíos (mock) con Interoperability

El proyecto expone un pequeño endpoint /api/shipping/status a través de la Interoperabilidad de IRIS — perfecto para simular llamadas “del mundo real”:

curl -H "Content-Type: application/json" \
  -X POST \
  -d '{"orderStatus":"Processing","trackingNumber":"DHL7788"}' \
  http://localhost:52773/api/shipping/status

Ahora abre Visual Trace en el Portal para ver el flujo de mensajes paso a paso (como el radar de un aeropuerto ✈️).

6) 🤖 Conoce al agente (smolagents + tools)

Echa un vistazo a estos archivos:

• agent/customer_support_agent.py — inicia un CodeAgent y registra las herramientas
• agent/tools/sql_tool.py — utilidades SQL parametrizadas
• agent/tools/rag_tool.py — búsqueda vectorial + recuperación de documentos
• agent/tools/shipping_tool.py — llamadas al endpoint de Interoperability

El CodeAgent planifica qué pasos dar y genera código que llama a tus herramientas. Tú pones las herramientas; él pone el cerebro con un modelo LLM.

7) ▶️ Ejecútalo

Modo one-shot (pruebas rápidas)

python -m cli.run --email alice@example.com --message "Where is my order #1001?"
python -m cli.run --email alice@example.com --message "Show electronics that are good for travel"
python -m cli.run --email alice@example.com --message "Was my headphones order delivered, and what’s the return window?"

CLI interactivo

python -m cli.run --email alice@example.com

Web UI (Gradio)

python -m ui.gradio
# open http://localhost:7860

🛠️ ¿Cómo funciona?

Flujo del agente (simplificado):

1. 🧭 Planifica cómo resolver la pregunta y qué herramientas usar: p. ej., “comprobar estado del pedido → buscar política de devoluciones”.

2. 🛤️ Llama a las herramientas según se necesite

   • 🗃️ SQL para clientes/pedidos/productos
   • 📚 RAG sobre embeddings para FAQs/docs (recuerda que puedes prototipar RAG directamente en SQL con EMBEDDING() + operaciones vectoriales como arriba)
   • 🔌 Interoperability API para estado de envíos

3. 🧩 Sintetiza: compone una respuesta clara y precisa.

Añade o cambia herramientas según crezca tu caso de uso: promociones, garantías, inventario, etc.

🎁 Resumen

Ya tienes un Agente de Atención al Cliente compacto que combina:

• 🧠 Razonamiento LLM (smolagents CodeAgent)
• 🗃️ Datos estructurados (IRIS SQL)
• 📚 Conocimiento no estructurado (IRIS Vector Search + RAG) — con el plus de que EMBEDDING() te permite búsqueda híbrida + vectorial directamente desde SQL
• 🔌 Llamadas a sistemas en vivo (IRIS Interoperability + Visual Trace)

Al comenzar con InterSystems IRIS o Caché, los desarrolladores a menudo se encuentran con tres conceptos fundamentales: Dynamic Objects, Globals y Relational Table. Cada uno tiene su papel en la construcción de soluciones escalables y mantenibles. En este artículo recorreremos ejemplos prácticos de código, destacaremos buenas prácticas y mostraremos cómo estos conceptos se relacionan entre sí.

1. Trabajando con Dynamic Objects:

El artículo de la August Article Bounty en Global Masters llamó mi atención, y uno de los temas propuestos me pareció bastante interesante para tratarlo. Así que esto es lo que me gustaría contarles a mis estudiantes sobre las tablas en IRIS y cómo se relacionan con el modelo de objetos.

Ante todo, InterSystems IRIS cuenta con un modelo de datos unificado. Esto significa que, cuando trabajáis con datos, no estáis atados a un único paradigma. Los mismos datos pueden ser accedidos y manipulados como una tabla SQL tradicional, como un objeto nativo o incluso como un array multidimensional (un global).

Esto quiere decir que, cuando creáis una tabla en SQL, IRIS genera automáticamente una clase de objeto correspondiente. Y, cuando definís una clase de objeto, IRIS la pone automáticamente a disposición como una tabla SQL. Los datos en sí mismos se almacenan una sola vez en el motor de almacenamiento multidimensional de IRIS, que es muy eficiente. El motor SQL y el motor de objetos son simplemente diferentes “lentes” para ver y trabajar con los mismos datos.

Primero, veamos la correlación entre el modelo relacional y el modelo de objetos:

La inyección SQL sigue siendo una de las vulnerabilidades más críticas en las aplicaciones basadas en bases de datos, ya que permite a los atacantes manipular consultas y, potencialmente, acceder o comprometer datos sensibles. En InterSystems IRIS, los desarrolladores tienen acceso tanto a SQL Dinámico como a SQL Embebido, cada uno con características distintas. Comprender cómo usarlos de forma segura es esencial para prevenir la inyección SQL.

El problema: SQL Dinámico y la inyección SQL

Quizá esto sea bien conocido, pero quería ayudar a compartirlo.

Considerad que tenéis las siguientes definiciones de clases persistentes:

Una clase Factura con una propiedad que referencia a Proveedor.

Introducción

InterSystems IRIS permite crear APIs REST utilizando clases ObjectScript y el framework %CSP.REST. Esta funcionalidad permite desarrollar servicios modernos para exponer datos a aplicaciones web, móviles o integraciones externas.

En este artículo aprenderás cómo crear una API REST básica en InterSystems IRIS, incluyendo:

• Clase de datos persistente
• Clase REST con métodos GET y POST
• Web application para exponer la API
• Demostración completa con Docker

Paso 1: Crear la clase de datos Demo.Producto

¡Hola desarrolladores!

El Cuarto Concurso de Artículos Técnicos ha terminado. ¡Gracias a todos los participantes!

🤩 Habéis aportado 10 ARTÍCULOS INCREÍBLES, y ya podemos anunciar los ganadores.

Un fuerte aplauso para estos desarrolladores y sus artículos:

🏆 Nominación de los expertos - los ganadores han sido elegidos por un jurado especialmente formado para el concurso:

🥇 1^er puesto: Carlos Castro con ¡POLICIA POLICIA! ¡¡Hay un intruso!! (Notificaciones Telegram y manejo URLs OAUTH2)

🥈 2º puesto: Miguelio con Persistencia de sesión Oauth con token OpenID en cookie

Si estáis migrando de Oracle a InterSystems IRIS, como muchos de mis clientes, podríais encontraros con patrones SQL específicos de Oracle que necesitan ser traducidos.

Tomad este ejemplo:

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);

En Oracle:

InterSystems IRIS permite ejecutar consultas SQL directamente desde ObjectScript mediante:

• SQL Embebido (Embedded SQL): consultas SQL compiladas en tiempo de desarrollo, con chequeo de tipos y mayor eficiencia.
• SQL Dinámico (Dynamic SQL): permite construir y ejecutar sentencias SQL en tiempo de ejecución, ideal para casos flexibles o condicionales.

Que es SQL (Structured Query Language) es un lenguaje estándar utilizado para interactuar con bases de datos relacionales. Permite realizar operaciones como:

Uso de Python en InterSystems Iris

Hola

En este artículo veremos el uso de python como lenguaje de programación en InterSystems Iris. Para ello, utilizaremos como referencia la versión de Community 2025.1 que está disponible para ser descargada en https:// download.intersystems.com iniciando sesión en el entorno. Para obtener más información sobre cómo descargar e instalar Iris, consulte el enlace de la comunidad https://community.intersystems.com/post/how-download-and-install-intersystems-iris

Hola comunidad,

Me preguntaba si sería posible usar algo como EnsLib.SQL.InboundAdapter con tablas en IRIS.

Esta biblioteca monitoriza cuándo se inserta un registro en una tabla de una base de datos externa, por lo que requiere un DSN para conectarse a dicha base de datos.

Mi objetivo es realizar una llamada a una API externa que tarda mucho tiempo, podría tardar casi una hora (o más) en completar sus procesos, pero no quiero bloquear el proceso principal.

Cuando trabajáis con InterSystems IRIS, los desarrolladores y arquitectos de bases de datos a menudo se enfrentan a una decisión crítica: si usar SQL Dinámico o SQL Embebido para consultar y actualizar datos. Ambos métodos tienen sus propias fortalezas y casos de uso, pero comprender sus implicaciones en el rendimiento es esencial para tomar la decisión correcta. El tiempo de respuesta, una métrica clave en la evaluación del rendimiento de las aplicaciones, puede variar significativamente dependiendo del enfoque de SQL que utilicéis. El SQL Dinámico ofrece flexibilidad, ya que las consultas pueden construirse y ejecutarse en tiempo de ejecución, lo que lo hace ideal para escenarios con necesidades de consulta impredecibles o altamente variables. Por el contrario, el SQL Embebido enfatiza la estabilidad y eficiencia al integrar el código SQL directamente en la lógica de la aplicación, ofreciendo tiempos de respuesta optimizados para patrones de consulta predefinidos.

En este artículo, exploraré los tiempos de respuesta al usar estos dos tipos de SQL y cómo dependen de las diferentes estructuras de clases y del uso de parámetros. Para ello, voy a utilizar las siguientes clases del diagrama:

Las versiones de mantenimiento 2024.1.4 y 2023.1.6 de la plataforma de datos InterSystems IRIS®, InterSystems IRIS® for Health™ y HealthShare®Health Connect ya están disponibles de forma general (GA). Estas versiones incluyen las correcciones para la siguiente alerta emitida recientemente: Alerta: Consultas SQL que devuelven resultados incorrectos | InterSystems. Por favor, compartid vuestros comentarios a través de la Comunidad de Desarrolladores para que podamos construir un mejor producto juntos.

Documentación

Migrar desde Oracle, MSSQL u otros sistemas de bases de datos puramente relacionales a un sistema multimodelo como InterSystems IRIS es una decisión estratégica que requiere una planificación y ejecución cuidadosas. Aunque esta transición ofrece beneficios significativos, como un mejor rendimiento, escalabilidad y soporte para arquitecturas modernas, también conlleva desafíos. En este artículo destacaré algunas de las consideraciones relacionadas con la codificación para asegurar una migración exitosa. Dejaré fuera del alcance de este artículo todo lo relacionado con la migración real de estructuras y datos.

Primero, cuando estáis considerando migrar a un sistema de base de datos diferente, necesitáis comprender vuestra lógica de negocio, ya sea del lado de la aplicación (servidor de aplicaciones) o del servidor de bases de datos. Básicamente, ¿dónde tenéis vuestras sentencias SQL que potencialmente tendréis que reescribir?

Lo que encuentro realmente útil de IRIS al enseñar mi asignatura de bases de datos post-relacionales es el hecho de que es una base de datos multimodelo. Lo que significa que podéis abordar la arquitectura y la estructura una sola vez y, después, mostrar el uso de diferentes modelos (como el objeto, documento, jerárquico) utilizando el mismo lenguaje y enfoque. Y no es un gran salto pasar de un lenguaje de programación orientado a objetos (como C#, Java, etc.) a una base de datos orientada a objetos.

Sin embargo, junto con las ventajas (que son muchas), vienen algunos inconvenientes cuando pasamos del modelo orientado a objetos al relacional. Cuando digo que podéis acceder a los mismos datos utilizando diferentes modelos, también necesito explicar cómo es posible trabajar con listas y arrays del modelo objeto en una tabla relacional. Con los arrays es muy sencillo: por defecto se representan como tablas separadas y eso es todo. Con las listas es más complicado, porque por defecto son cadenas de texto. Pero uno sigue queriendo hacer algo con ellas sin dañar la estructura ni volver esta lista ilegible en el modelo objeto.

Así que en este artículo os mostraré un par de predicados y una función que son útiles al trabajar con listas, y no solo como campos.

InterSystems anuncia la disponibilidad general de InterSystems IRIS, InterSystems IRIS for Health y HealthShare Health Connect 2025.1

La versión 2025.1 de la plataforma de datos InterSystems IRIS®, InterSystems IRIS® for Health™ y HealthShare® Health Connect ya está disponible de manera general (GA). Esta es una versión de Mantenimiento Extendido (EM).

Aspectos destacados de la versión
En esta emocionante versión, los usuarios pueden esperar varias nuevas funciones y mejoras, entre ellas:

Después de tantos años de espera, por fin tenemos un controlador oficial disponible en Pypi

Además, encontré el driver JDBC finalmente disponible en Maven desde hace ya 3 meses, y el driver .Net en Nuget desde hace más de un mes.

Como autor de multitud de implementaciones de librerías de Python con soporte de IRIS, quería probarlo. La implementación de DB-API significa que debe ser reemplazable e implementar las funciones definidas en el estándar. La única diferencia entre las diferentes bases de datos debería ser únicamente el SQL.

Y la belleza de usar librerías existentes que ya implementaron la conectividad con otras bases de datos usando el estándar DB-API, es que estas librerías deberían ser totalmente compatibles con el controlador.

Decidí probar el driver oficial de InterSystems implementando su soporte en la librería SQLAlchemy-iris.

Hola, comunidad de IRIS,

InterSystems Certification está desarrollando un examen de certificación para profesionales desarrolladores de InterSystems IRIS, y si coincidís con la descripción del candidato al examen que se indica a continuación, nos gustaría que participéis en la prueba beta del examen.

Hola,

19 de febrero de 2025 – Alerta: Consultas SQL que están devolviendo resultados incorrectos

InterSystems ha corregido dos problemas que pueden hacer que un pequeño número de consultas SQL devuelvan resultados incorrectos. Además, ha solucionado una inconsistencia en el manejo de los tipos de datos de fecha y hora, lo que podría provocar que algunas aplicaciones existentes que dependían del comportamiento anterior e inconsistente obtengan resultados diferentes e inesperados, aunque correctos.

DP-436825: Algunas consultas SQL con Lateral Join pueden devolver resultados incorrectos

Tengo una tabla con un campo TimeStamp. Necesito crearle un índice para mejorar la ejecución de consultas. Pero estoy dándole vueltas a cuál podría ser la mejor opción.

Variables de host son una característica de programación bastante común en muchas implementaciones de SQL.
Una pregunta reciente en DC me hizo darme cuenta de que en IRIS, Caché, Ensemble,... 
las variables del host simplemente existen dentro del embedded SQL.

>  You can supply host variables for Embedded SQL queries only. <
Se incluyen ejemplos relacionados en la documentación disponible.

A continuación se incluye una descripción de una solución alternativa si no utiliza o no puede utilizar embedded SQL.

No estoy seguro de que haya muchos que se conecten a MS SQL para ejecutar consultas, procedimientos almacenados, etc., pero nuestro sistema de salud tiene muchas bases de datos diferentes basadas en MS SQL que usamos en el entorno de interoperabilidad por diversas razones.

Con el impulso de movernos de on-premises a la nube, nos encontramos con algunas dificultades con nuestras conexiones SQL Gateway y cómo configurarlas para usar Microsoft Entra para la autenticación de Active Directory.