A espera acabou: bem-vindo ao suporte a GoLang para InterSystems IRIS

Introdução

A plataforma de dados InterSystems IRIS há muito tempo é conhecida por seu desempenho, interoperabilidade e flexibilidade entre linguagens de programação. Durante anos, os desenvolvedores puderam usar o IRIS com Python, Java, JavaScript e .NET — mas os desenvolvedores de Go (ou Golang) ficaram esperando.

Essa espera finalmente acabou.

O novo driver go-irisnative traz suporte a GoLang para o InterSystems IRIS, implementando a API padrão database/sql. Isso significa que os desenvolvedores Go agora podem usar ferramentas de banco de dados familiares, gerenciamento de conexões e interfaces de consulta para criar aplicações impulsionadas pelo IRIS.

Por que o suporte a GoLang é importante

GoLang é uma linguagem projetada para simplicidade, concorrência e desempenho — ideal para arquiteturas nativas de nuvem e baseadas em microsserviços. Ela impulsiona alguns dos sistemas mais escaláveis do mundo, incluindo Kubernetes, Docker e Terraform.

Integrar o IRIS ao ecossistema Go possibilita:

• Serviços leves e de alto desempenho usando o IRIS como backend.
• Concorrência nativa para execução paralela de consultas ou processamento em segundo plano.
• Integração perfeita com sistemas distribuídos e conteinerizados.
• Acesso idiomático ao banco de dados por meio da interface database/sql do Go.

Essa integração torna o IRIS uma escolha perfeita para aplicações Go modernas e preparadas para a nuvem.

Começando

1. Instalação

go get github.com/caretdev/go-irisnative

2. Conectando ao IRIS

Veja como se conectar usando a API padrãodatabase/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. Criando uma tabela

Vamos criar uma tabela de demonstração simples:

_, 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. Inserindo dados

No momento, inserções de múltiplas linhas não são suportadas — insira uma linha por chamada:

_, 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. Consultando dados

A consulta é simples usando a interface 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)
}

Isso é tudo o que você precisa para realizar operações SQL básicas a partir do Go.

Como Funciona

Por baixo do capô, o driver go-irisnative utiliza a API Nativa do IRIS para uma comunicação eficiente e de baixo nível com o banco de dados. O driver implementa as interfaces padrão database/sql/driver do Go, tornando-o compatível com ferramentas Go existentes, como:

• sqlx
• gorm (com um dialeto personalizado)
• Ferramentas padrão de migração do Go

Isso oferece aos desenvolvedores uma API familiar, com a potência e o desempenho do acesso nativo ao IRIS.

Exemplos de Casos de Uso

• Microsserviços — serviços Go leves conectando-se diretamente ao IRIS.
• APIs de dados — expor endpoints REST ou gRPC suportados pelo IRIS.
• Ferramentas de integração — conectar dados do IRIS a outros sistemas em pipelines baseados em Go.
• Aplicações IRIS nativas de nuvem — implantar aplicativos Go com suporte do IRIS no Kubernetes ou Docker.

Testando com Testcontainers

Se você quiser executar testes automatizados sem gerenciar uma instância ativa do IRIS, pode usar otestcontainers-iris-go.
Ele inicia um contêiner IRIS temporário para testes de integração.

Exemplo de configuração de teste:

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

Isso é ideal para pipelines de CI/CD ou testes unitários, garantindo que sua aplicação Go funcione perfeitamente com o IRIS de forma isolada.

Conclusões

O suporte a GoLang para o InterSystems IRIS chegou — e é um divisor de águas.
Com o go-irisnative, você agora pode criar aplicações escaláveis, concorrentes e nativas de nuvem que aproveitam diretamente o poder do IRIS.

Seja construindo microsserviços, APIs ou ferramentas de integração, o Go oferece simplicidade e desempenho, enquanto o IRIS oferece confiabilidade e recursos avançados de dados.

👉 Experimente:

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