Go Academy · Aula

Instruções preparadas

Execute consultas parametrizadas

Instruções preparadas é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

O que é uma instrução preparada

Uma instrução preparada envia o texto SQL ao banco de dados uma vez para ser analisado e planejado, e depois o executa muitas vezes com parâmetros diferentes. Ela é mais rápida para consultas repetidas e mais segura contra injeção.

Marcadores de parâmetros

Nunca crie SQL concatenando a entrada do usuário. Use marcadores para que o controlador envie os valores separadamente. PostgreSQL usa $1, $2; MySQL e SQLite usam ?.

SELECT * FROM users WHERE age > $1 AND city = $2

Por que isso impede a injeção

Como os parâmetros são enviados separadamente do texto SQL, o banco de dados os trata estritamente como dados, nunca como código. Um valor malicioso como " OR 1=1 torna-se uma string literal, não um SQL executável.

db.Prepare

Prepare retorna um *sql.Stmt associado ao conjunto de conexões. Em seguida, você chama Exec ou Query na instrução com os argumentos.

stmt, err := db.Prepare("INSERT INTO users(name, age) VALUES($1, $2)")
if err != nil {
    log.Fatal(err)
}
defer stmt.Close()

Executando a instrução

Chame stmt.Exec com os argumentos correspondentes a cada marcador. Para inserções e atualizações, Exec retorna um sql.Result com o número de linhas afetadas e o ID da última inserção.

res, err := stmt.Exec("Ada", 36)
if err != nil {
    log.Fatal(err)
}
n, _ := res.RowsAffected()
fmt.Println("inserted", n)

Reutilizando em um laço

O ganho vem da reutilização: prepare uma vez e execute muitas vezes dentro de um laço. O banco de dados reutiliza seu plano analisado a cada chamada.

for _, u := range users {
    if _, err := stmt.Exec(u.Name, u.Age); err != nil {
        log.Fatal(err)
    }
}

Preparação implícita

Passar argumentos diretamente para db.Query ou db.Exec também usa marcadores com segurança; o controlador pode preparar a instrução internamente. Prepare explícito é importante principalmente para execuções repetidas.

Uma simulação executável de vinculação de parâmetros

Instruções preparadas reais precisam de um banco de dados. Este exemplo executável simula a vinculação segura de parâmetros para mostrar como os valores permanecem separados do texto da consulta.

package main

import "fmt"

func execPrepared(query string, args ...interface{}) string {
    return fmt.Sprintf("EXEC %q with args %v", query, args)
}

func main() {
    q := "INSERT INTO users(name, age) VALUES($1, $2)"
    people := [][2]interface{}{{"Ada", 36}, {"Lin", 41}}
    for _, p := range people {
        fmt.Println(execPrepared(q, p[0], p[1]))
    }
}

Variantes de contexto

Use PrepareContext e stmt.ExecContext para que as chamadas preparadas respeitem os limites de tempo e o cancelamento, assim como o restante de database/sql.

Feche sempre a instrução

Um *sql.Stmt mantém recursos no banco de dados. Adie stmt.Close() quando terminar. O vazamento de instruções pode esgotar os limites de instruções preparadas no servidor.

Instruções e agrupamento de conexões

Uma instrução preparada em *sql.DB funciona em todas as conexões agrupadas; a biblioteca a prepara novamente na conexão em que ela for utilizada. Normalmente, você não precisa gerenciar isso.

Verificação rápida

Teste seus conhecimentos sobre instruções preparadas.

Recapitulação

Você aprendeu sobre instruções preparadas:

Prepare analisa uma vez e executa várias vezes
Os marcadores de posição ($1 ou ?) mantêm os valores como dados, impedindo a injeção
stmt.Exec retorna o número de linhas afetadas; adie stmt.Close()
Reutilize em laços; use variantes de Contexto para prazos

Perguntas Frequentes

A aula “Instruções preparadas” é grátis?

Sim — o texto completo de “Instruções preparadas” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “Instruções preparadas”?

Execute consultas parametrizadas Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Go Academy?

Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Instruções preparadas”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Go Academy?

Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Go Academy