Introducción
La plataforma de datos InterSystems IRIS ha sido conocida durante mucho tiempo por su rendimiento, interoperabilidad y flexibilidad entre distintos lenguajes de programación. Durante años, los desarrolladores pudieron usar IRIS con Python, Java, JavaScript y .NET, pero los desarrolladores de Go (o Golang) tuvieron que esperar.
Esa espera finalmente ha terminado.
El nuevo controlador go-irisnative incorpora soporte para GoLang en InterSystems IRIS, implementando la API estándar database/sql. Esto significa que los desarrolladores de Go ahora pueden utilizar herramientas de base de datos conocidas, agrupación de conexiones e interfaces de consulta para crear aplicaciones impulsadas por IRIS.
Por qué es importante el soporte para GoLang
GoLang es un lenguaje diseñado para la simplicidad, la concurrencia y el rendimiento, ideal para arquitecturas nativas en la nube y basadas en microservicios. Impulsa algunos de los sistemas más escalables del mundo, como Kubernetes, Docker y Terraform.
Integrar IRIS en el ecosistema de Go permite:
- Servicios ligeros y de alto rendimiento utilizando IRIS como backend.
- Concurrencia nativa para la ejecución paralela de consultas o el procesamiento en segundo plano.
- Integración fluida con sistemas distribuidos y en contenedores.
- Acceso a bases de datos de forma idiomática mediante la interfaz
database/sqlde Go.
Esta integración convierte a IRIS en la opción perfecta para aplicaciones modernas y preparadas para la nube desarrolladas en Go.
Cómo empezar
1. Instalación
go get github.com/caretdev/go-irisnative2. Conectar a IRIS
Así es como se realiza la conexión utilizando la API estándar database/sql:
import (
"database/sql"
"fmt"
"log"
_ "github.com/caretdev/go-irisnative"
)
func main() {
db, err := sql.Open("iris", "iris://_SYSTEM:SYS@localhost:1972/USER")
if err != nil {
log.Fatal(err)
}
defer db.Close()
// Simple ping to test connection
if err := db.Ping(); err != nil {
log.Fatal("Failed to connect:", err)
}
fmt.Println("Connected to InterSystems IRIS!")
}3. Creación de una tabla
Vamos a crear una tabla de demostración sencilla:
_, err = db.Exec(`CREATE TABLE IF NOT EXISTS demo (
id INT PRIMARY KEY,
name VARCHAR(50)
)`)
if err != nil {
log.Fatal(err)
}
fmt.Println("Table created.")4. Inserción de datos
Por el momento, no se admiten inserciones de varias filas; se debe insertar una fila por cada llamada:
_, err = db.Exec(`INSERT INTO demo (id, name) VALUES (?, ?)`, 1, "Alice")
if err != nil {
log.Fatal(err)
}
_, err = db.Exec(`INSERT INTO demo (id, name) VALUES (?, ?)`, 2, "Bob")
if err != nil {
log.Fatal(err)
}
fmt.Println("Data inserted.")5. Consulta de datos
La consulta es sencilla utilizando la interfaz database/sql
rows, err := db.Query(`SELECT id, name FROM demo`)
if err != nil {
log.Fatal(err)
}
defer rows.Close()
for rows.Next() {
var id int
var name string
if err := rows.Scan(&id, &name); err != nil {
log.Fatal(err)
}
fmt.Printf("ID: %d, Name: %s\n", id, name)
}That’s all you need to perform basic SQL operations from Go.
Cómo funciona
Bajo el capó, el controlador go-irisnativeutiliza la API nativa de IRIS para una comunicación eficiente y de bajo nivel con la base de datos. El controlador implementa las interfaces estándar database/sql/driver de Go, lo que lo hace compatible con herramientas existentes de Go como:
sqlxgorm(con un dialecto personalizado)- Herramientas estándar de migración en Go
Esto ofrece a los desarrolladores una API familiar con la potencia y el rendimiento del acceso nativo a IRIS.
Ejemplos de casos de uso
- Microservicios — servicios ligeros en Go conectados directamente a IRIS.
- APIs de datos — exposición de endpoints REST o gRPC respaldados por IRIS.
- Herramientas de integración — conexión de los datos de IRIS con otros sistemas en flujos desarrollados en Go.
- Aplicaciones IRIS nativas en la nube — despliegue de aplicaciones en Go respaldadas por IRIS en Kubernetes o Docker.
Pruebas con Testcontainers
Si deseas ejecutar pruebas automatizadas sin tener que gestionar una instancia activa de IRIS, puedes usar testcontainers-iris-go.
Este lanza un contenedor temporal de IRIS para realizar pruebas de integración.
Ejemplo de configuración de prueba:
import (
"context"
"database/sql"
"flag"
"log"
"os"
"testing"
iriscontainer "github.com/caretdev/testcontainers-iris-go"
"github.com/stretchr/testify/require"
"github.com/testcontainers/testcontainers-go"
)
var connectionString string = "iris://_SYSTEM:SYS@localhost:1972/USER"
var container *iriscontainer.IRISContainer = nil
func TestMain(m *testing.M) {
var (
useContainer bool
containerImage string
)
flag.BoolVar(&useContainer, "container", true, "Use container image.")
flag.StringVar(&containerImage, "container-image", "", "Container image.")
flag.Parse()
var err error
ctx := context.Background()
if useContainer || containerImage != "" {
options := []testcontainers.ContainerCustomizer{
iriscontainer.WithNamespace("TEST"),
iriscontainer.WithUsername("testuser"),
iriscontainer.WithPassword("testpassword"),
}
if containerImage != "" {
container, err = iriscontainer.Run(ctx, containerImage, options...)
} else {
// or use default docker image
container, err = iriscontainer.RunContainer(ctx, options...)
}
if err != nil {
log.Println("Failed to start container:", err)
os.Exit(1)
}
defer container.Terminate(ctx)
connectionString = container.MustConnectionString(ctx)
log.Println("Container started successfully", connectionString)
}
var exitCode int = 0
exitCode = m.Run()
if container != nil {
container.Terminate(ctx)
}
os.Exit(exitCode)
}
func openDbWrapper[T require.TestingT](t T, dsn string) *sql.DB {
db, err := sql.Open(`intersystems`, dsn)
require.NoError(t, err)
require.NoError(t, db.Ping())
return db
}
func closeDbWrapper[T require.TestingT](t T, db *sql.DB) {
if db == nil {
return
}
require.NoError(t, db.Close())
}
func TestConnect(t *testing.T) {
db := openDbWrapper(t, connectionString)
defer closeDbWrapper(t, db)
var (
namespace string
username string
)
res := db.QueryRow(`SELECT $namespace, $username`)
require.NoError(t, res.Scan(&namespace, &username))
require.Equal(t, "TEST", namespace)
require.Equal(t, "testuser", username)
}
Esto es ideal para pipelines de CI/CD o pruebas unitarias, garantizando que tu aplicación en Go funcione perfectamente con IRIS de forma aislada.
Conclusión
El soporte de GoLang para InterSystems IRIS ya está aquí, y marca un antes y un después.
Con go-irisnative, ahora puedes crear aplicaciones escalables, concurrentes y nativas en la nube que aprovechen directamente la potencia de IRIS.
Tanto si estás desarrollando microservicios, APIs o herramientas de integración, Go te ofrece simplicidad y rendimiento, mientras que IRIS te brinda fiabilidad y amplias capacidades de gestión de datos.
👉 Probadlo:
Open Exchange.png)