La espera ha terminado: damos la bienvenida al soporte de GoLang para InterSystems IRIS

Introducción

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/sql de 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-irisnative

2. 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:

• sqlx
• gorm (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:

• go-irisnative on GitHub
• testcontainers-iris-go for testing