Gabarito do exercício 1

O tokenizador em código

def tokeniza(sql):
    tokens, i = [], 0
    while i < len(sql):
        c = sql[i]
        if c.isspace(): i += 1
        elif c.isalpha():                               # palavra reservada ou nome
            j = i
            while j < len(sql) and (sql[j].isalnum() or sql[j] == "_"): j += 1
            p = sql[i:j]
            tokens.append(("PALAVRA", p.upper()) if p.upper() in PALAVRAS else ("NOME", p))
            i = j
        elif c.isdigit(): ...                           # mesmo laço, com isdigit
        elif c == "'":                                  # texto vai até a próxima aspa
            j = sql.find("'", i + 1)
            if j < 0: raise ErroLexico(f"aspas sem fechamento na posição {i}")
            tokens.append(("TEXTO", sql[i + 1:j]))
            i = j + 1
        elif c in "(),;*=":
            tokens.append(("SIMBOLO", c)); i += 1
        else: raise ErroLexico(f"caractere inesperado {c!r} na posição {i}")
    return tokens + [("FIM", None)]

Descida recursiva: uma função por regra

def create(self):
    self.espera("PALAVRA", "CREATE")
    self.espera("PALAVRA", "TABLE")
    tabela = self.espera("NOME")
    self.espera("SIMBOLO", "(")
    colunas = [self.coluna()]
    while self.aceita("SIMBOLO", ","):
        colunas.append(self.coluna())
    self.espera("SIMBOLO", ")")
    return {"op": "CREATE", "tabela": tabela, "colunas": colunas}

def coluna(self):
    nome = self.espera("NOME")
    if self.aceita("PALAVRA", "INT"):
        return (nome, "INT", 4)
    self.espera("PALAVRA", "CHAR")
    self.espera("SIMBOLO", "(")
    n = self.espera("NUMERO")
    self.espera("SIMBOLO", ")")
    return (nome, "CHAR", n)

O esqueleto do M4: o parser

class Parser:
    def __init__(self, tokens):
        self.tokens, self.i = tokens, 0
    def olha(self):
        return self.tokens[self.i]
    def aceita(self, tipo, valor):
        if self.tokens[self.i] == (tipo, valor):
            self.i += 1
            return True
        return False
    def espera(self, tipo, valor=None):
        t, v = self.tokens[self.i]
        if t != tipo or (valor is not None and v != valor):
            raise ErroSintatico(f"esperava {valor or tipo}, veio {v!r}")
        self.i += 1
        return v
    def valor(self):
        t, v = self.olha()
        if t in ("NUMERO", "TEXTO"):
            self.i += 1
            return v
        raise ErroSintatico(f"esperava valor, veio {v!r}")

O esqueleto do M4: o comando

def comando(self):
    _, v = self.olha()
    if v == "CREATE":   arvore = self.create()
    elif v == "INSERT": arvore = self.insert()     # mesmo molde do create, com valor
    elif v == "SELECT": arvore = self.select()
    else: raise ErroSintatico(f"comando desconhecido {v!r}")
    self.aceita("SIMBOLO", ";")
    self.espera("FIM")                            # sobrou token? é erro
    return arvore

def analisa(sql):                                 # o que o resto do minidb chama
    return Parser(tokeniza(sql)).comando()

O esqueleto do M4: o SELECT

def select(self):
    self.espera("PALAVRA", "SELECT")
    if self.aceita("SIMBOLO", "*"):
        colunas = ["*"]
    else:
        colunas = [self.espera("NOME")]
        while self.aceita("SIMBOLO", ","):
            colunas.append(self.espera("NOME"))
    self.espera("PALAVRA", "FROM")
    tabela = self.espera("NOME")
    where = None
    if self.aceita("PALAVRA", "WHERE"):
        coluna = self.espera("NOME")
        self.espera("SIMBOLO", "=")
        where = (coluna, self.valor())
    return {"op": "SELECT", "colunas": colunas, "tabela": tabela, "where": where}

O parser já aceita o WHERE. Quem vai executá-lo é o M5.

O esqueleto do M4: o INSERT

def insert(self):
    self.espera("PALAVRA", "INSERT")
    self.espera("PALAVRA", "INTO")
    tabela = self.espera("NOME")
    self.espera("PALAVRA", "VALUES")
    self.espera("SIMBOLO", "(")
    valores = [self.valor()]
    while self.aceita("SIMBOLO", ","):
        valores.append(self.valor())
    self.espera("SIMBOLO", ")")
    return {"op": "INSERT", "tabela": tabela, "valores": valores}

O mesmo molde do create, com valor no lugar de coluna. O parser não confere se o valor bate com o tipo da coluna: isso é semântica, e precisa do catálogo.

O programa: o laço principal

import sys

def executa(sql, catalogo, cache):
    arvore = analisa(sql)                    # M4, hoje
    ...                                      # M4, parte 2: catálogo, M1 e M2

pager = Pager(sys.argv[1])                   # M1
cache = Cache(pager)                         # M2
catalogo = Catalogo(cache)                   # M4, parte 2

for linha in sys.stdin:
    if linha.strip():
        print(executa(linha, catalogo, cache))

cache.descarrega()                           # M2: páginas sujas vão para o disco

É isso que transforma a biblioteca do M1 ao M3 num programa que lê SQL da entrada padrão.

Injeção de SQL em código

# concatenação: o texto do usuário vira gramática
sql = "SELECT * FROM aluno WHERE nome = '" + nome + "'"
banco.execute(sql)
# nome = x' OR '1'='1    →  devolve a tabela inteira

# parâmetro: a consulta é analisada antes, e o valor entra depois
banco.execute("SELECT * FROM aluno WHERE nome = ?", (nome,))
# nome = x' OR '1'='1    →  devolve nada

Para rodar: python3 injecao.py, em /assets/code/bd2-2026/. Só precisa do Python. Tente também python3 injecao.py "x' UNION SELECT 0, sql, 0 FROM sqlite_schema --".