PHP code example of omegaalfa / query-builder

    
        
<?php
require_once('vendor/autoload.php');

/* Start to develop here. Best regards https://php-download.com/ */

    

omegaalfa / query-builder example snippets

declare(strict_types=1);

use Omegaalfa\QueryBuilder\connection\PDOConnection;
use Omegaalfa\QueryBuilder\connection\DatabaseSettings;
use Omegaalfa\QueryBuilder\QueryBuilder;
use Omegaalfa\QueryBuilder\Paginator;

// 1. Configurar conexão
$config = new DatabaseSettings(
    driver: 'mysql',
    host: 'localhost',
    database: 'meu_banco',
    username: 'root',
    password: '',
    port: 3306,
    charset: 'utf8mb4'
);

// 2. Criar instâncias
$connection = new PDOConnection($config);
$paginator = new Paginator();
$qb = new QueryBuilder($connection, $paginator);

// 3. Usar!
$result = $qb
    ->select('usuarios', ['id', 'nome', 'email'])
    ->where('ativo', SqlOperator::EQUALS, true)
    ->orderBy('nome', OrderDirection::ASC)
    ->limit(10)
    ->execute();

foreach ($result->data as $usuario) {
    echo "{$usuario['nome']} - {$usuario['email']}\n";
}

public function select(string $table, array $fields = ['*']): self

// SELECT básico
$qb->select('usuarios');

// Campos específicos
$qb->select('produtos', ['id', 'nome', 'preco']);

// Com funções SQL
$qb->select('pedidos', ['id', 'COUNT(*) as total', 'SUM(valor) as total_valor']);

// Com aliases de tabela
$qb->select('usuarios', ['u.id', 'u.nome', 'u.email'])->alias('u');

$allowedFields = ['id', 'nome', 'email'];
$userFields = array_intersect($_GET['fields'], $allowedFields);
$qb->select('usuarios', $userFields);

public function insert(string $table, array $data): self

$qb->insert('usuarios', [
    'nome' => 'João Silva',
    'email' => '[email protected]',
    'ativo' => true,
    'criado_em' => new DateTime()
])->execute();

// Obter ID inserido
$novoId = $qb->getInsertId();
echo "Registro criado com ID: {$novoId}";

public function insertBatch(string $table, array $data): self

$usuarios = [
    ['nome' => 'João', 'email' => '[email protected]'],
    ['nome' => 'Maria', 'email' => '[email protected]'],
    ['nome' => 'Pedro', 'email' => '[email protected]']
];

$qb->insertBatch('usuarios', $usuarios)->execute();

public function update(string $table, array $data): self

// Atualizar com WHERE
$qb->update('usuarios', [
    'nome' => 'João Santos',
    'atualizado_em' => new DateTime()
])
->where('id', SqlOperator::EQUALS, 123)
->execute();

// Atualizar múltiplos registros
$qb->update('produtos', ['ativo' => false])
   ->where('estoque', SqlOperator::EQUALS, 0)
   ->execute();

public function delete(string $table): self

// Deletar com WHERE
$qb->delete('usuarios')
   ->where('ativo', SqlOperator::EQUALS, false)
   ->where('ultimo_acesso', SqlOperator::LESS_THAN, '2020-01-01')
   ->execute();

// Deletar por ID
$qb->delete('produtos')
   ->where('id', SqlOperator::EQUALS, 456)
   ->execute();

public function where(string $column, SqlOperator|string $operator, mixed $value): self

// Comparação simples
$qb->select('usuarios')
   ->where('ativo', SqlOperator::EQUALS, true)
   ->where('idade', SqlOperator::GREATER_THAN, 18);

// LIKE
$qb->select('produtos')
   ->where('nome', SqlOperator::LIKE, '%notebook%');

// Múltiplas condições (AND)
$qb->select('pedidos')
   ->where('status', SqlOperator::EQUALS, 'pendente')
   ->where('valor', SqlOperator::GREATER_THAN, 100)
   ->where('criado_em', SqlOperator::GREATER_THAN, '2024-01-01');

public function orWhere(string $column, SqlOperator|string $operator, mixed $value): self

// WHERE status = 'pendente' OR status = 'processando'
$qb->select('pedidos')
   ->where('status', SqlOperator::EQUALS, 'pendente')
   ->orWhere('status', SqlOperator::EQUALS, 'processando');

// WHERE (categoria = 'A' OR categoria = 'B') AND ativo = true
$qb->select('produtos')
   ->where('categoria', SqlOperator::EQUALS, 'A')
   ->orWhere('categoria', SqlOperator::EQUALS, 'B')
   ->where('ativo', SqlOperator::EQUALS, true);

public function whereIn(string $column, array $values): self

// WHERE id IN (1, 2, 3, 4, 5)
$qb->select('usuarios')
   ->whereIn('id', [1, 2, 3, 4, 5]);

// WHERE status IN ('pendente', 'aprovado', 'processando')
$qb->select('pedidos')
   ->whereIn('status', ['pendente', 'aprovado', 'processando']);

public function whereNotIn(string $column, array $values): self

// WHERE status NOT IN ('cancelado', 'rejeitado')
$qb->select('pedidos')
   ->whereNotIn('status', ['cancelado', 'rejeitado']);

public function whereBetween(string $column, array $range): self

// WHERE preco BETWEEN 100 AND 500
$qb->select('produtos')
   ->whereBetween('preco', [100, 500]);

// WHERE data BETWEEN '2024-01-01' AND '2024-12-31'
$qb->select('pedidos')
   ->whereBetween('criado_em', ['2024-01-01', '2024-12-31']);

public function whereNotBetween(string $column, array $range): self

public function whereNull(string $column): self

// WHERE deletado_em IS NULL
$qb->select('usuarios')
   ->whereNull('deletado_em');

public function whereNotNull(string $column): self

// WHERE email IS NOT NULL
$qb->select('usuarios')
   ->whereNotNull('email');

public function join(
    string $table, 
    string $key, 
    string $operator, 
    string $refer, 
    JoinType $type = JoinType::INNER
): self

// INNER JOIN
$qb->select('usuarios', ['usuarios.id', 'usuarios.nome', 'pedidos.total'])
   ->join('pedidos', 'usuarios.id', '=', 'pedidos.usuario_id')
   ->where('pedidos.status', SqlOperator::EQUALS, 'concluido');

// LEFT JOIN
$qb->select('categorias', ['categorias.nome', 'COUNT(produtos.id) as total_produtos'])
   ->join('produtos', 'categorias.id', '=', 'produtos.categoria_id', JoinType::LEFT)
   ->groupBy('categorias.id');

// Múltiplos JOINs
$qb->select('pedidos', ['*'])
   ->join('usuarios', 'pedidos.usuario_id', '=', 'usuarios.id')
   ->join('enderecos', 'usuarios.id', '=', 'enderecos.usuario_id', JoinType::LEFT)
   ->where('pedidos.status', SqlOperator::EQUALS, 'pendente');

public function groupBy(string $column): self

// Contar pedidos por status
$qb->select('pedidos', ['status', 'COUNT(*) as total'])
   ->groupBy('status');

// Múltiplos agrupamentos
$qb->select('vendas', ['ano', 'mes', 'SUM(valor) as total'])
   ->groupBy('ano')
   ->groupBy('mes');

public function having(string $column, SqlOperator $operator, mixed $value): self

// Categorias com mais de 10 produtos
$qb->select('produtos', ['categoria_id', 'COUNT(*) as total'])
   ->groupBy('categoria_id')
   ->having('total', SqlOperator::GREATER_THAN, 10);

// Usuários com mais de 5 pedidos
$qb->select('pedidos', ['usuario_id', 'COUNT(*) as total_pedidos'])
   ->groupBy('usuario_id')
   ->having('total_pedidos', SqlOperator::GREATER_THAN, 5);

public function havingRaw(string $condition): self

$qb->select('pedidos', ['usuario_id', 'SUM(valor) as total_gasto'])
   ->groupBy('usuario_id')
   ->havingRaw('SUM(valor) > AVG(valor) * 2');

public function orderBy(string $column, OrderDirection $direction = OrderDirection::ASC): self

// Ordenação simples
$qb->select('produtos')
   ->orderBy('nome', OrderDirection::ASC);

// Múltiplas ordenações
$qb->select('usuarios')
   ->orderBy('ativo', OrderDirection::DESC)
   ->orderBy('nome', OrderDirection::ASC);

// Ordenar por função
$qb->select('pedidos', ['*', 'DATE(criado_em) as data'])
   ->orderBy('data', OrderDirection::DESC);

public function limit(int $limit, int $offset = 0): self

// Primeiros 10 registros
$qb->select('produtos')->limit(10);

// Paginação: página 2, 20 por página
$page = 2;
$perPage = 20;
$offset = ($page - 1) * $perPage;
$qb->select('produtos')->limit($perPage, $offset);

// Com ordenação
$qb->select('usuarios')
   ->orderBy('criado_em', OrderDirection::DESC)
   ->limit(50);

public function count(string $column = '*'): int

// Total de usuários
$total = $qb->select('usuarios')->count();

// Total de usuários ativos
$ativos = $qb->select('usuarios')
             ->where('ativo', SqlOperator::EQUALS, true)
             ->count();

// Contar valores únicos
$categorias = $qb->select('produtos')->count('DISTINCT categoria_id');

public function sum(string $column): float

// Total de vendas
$total = $qb->select('pedidos')->sum('valor');

// Total de vendas aprovadas
$totalAprovado = $qb->select('pedidos')
                    ->where('status', SqlOperator::EQUALS, 'aprovado')
                    ->sum('valor');

public function avg(string $column): float

// Preço médio
$precoMedio = $qb->select('produtos')->avg('preco');

// Nota média de avaliações
$notaMedia = $qb->select('avaliacoes')
                ->where('produto_id', SqlOperator::EQUALS, 123)
                ->avg('nota');

public function min(string $column): mixed

// Menor preço
$menorPreco = $qb->select('produtos')
                 ->where('ativo', SqlOperator::EQUALS, true)
                 ->min('preco');

public function max(string $column): mixed

// Maior preço
$maiorPreco = $qb->select('produtos')->max('preco');

// Data mais recente
$ultimaCompra = $qb->select('pedidos')
                   ->where('usuario_id', SqlOperator::EQUALS, 123)
                   ->max('criado_em');

public function exists(): bool

// Verificar se usuário existe
$existe = $qb->select('usuarios')
             ->where('email', SqlOperator::EQUALS, '[email protected]')
             ->exists();

if ($existe) {
    echo "Email já cadastrado!";
}

public function raw(string $query, array $params = []): self

// Query complexa com CTE
$qb->raw('
    WITH vendas_por_mes AS (
        SELECT DATE_FORMAT(data, "%Y-%m") as mes, SUM(valor) as total
        FROM vendas
        WHERE ano = ?
        GROUP BY mes
    )
    SELECT * FROM vendas_por_mes WHERE total > ?
', [2024, 10000])->execute();

// Window functions
$qb->raw('
    SELECT 
        nome,
        valor,
        ROW_NUMBER() OVER (PARTITION BY categoria ORDER BY valor DESC) as ranking
    FROM produtos
')->execute();

public function alias(string $alias): self

$qb->select('usuarios', ['u.id', 'u.nome'])
   ->alias('u')
   ->join('pedidos', 'u.id', '=', 'pedidos.usuario_id')
   ->where('u.ativo', SqlOperator::EQUALS, true);

public function transactional(callable $callback): mixed

try {
    $pedidoId = $qb->transactional(function($qb, $pdo) {
        // 1. Criar pedido
        $qb->insert('pedidos', [
            'usuario_id' => 123,
            'total' => 99.90,
            'status' => 'pendente'
        ])->execute();
        
        $pedidoId = $qb->getInsertId();
        
        // 2. Adicionar itens
        $qb->insertBatch('itens_pedido', [
            ['pedido_id' => $pedidoId, 'produto_id' => 1, 'qtd' => 2],
            ['pedido_id' => $pedidoId, 'produto_id' => 5, 'qtd' => 1]
        ])->execute();
        
        // 3. Atualizar estoque
        $qb->update('produtos', ['estoque' => 'estoque - 2'])
           ->where('id', SqlOperator::EQUALS, 1)
           ->execute();
        
        return $pedidoId;
    });
    
    echo "Pedido criado: {$pedidoId}";
    
} catch (Exception $e) {
    // Rollback automático já foi executado
    echo "Erro: {$e->getMessage()}";
}

public function cache(int $ttl = 3600): self

// Cache por 1 hora
$result = $qb->select('configuracoes')
             ->cache(3600)
             ->execute();

// Cache por 5 minutos
$result = $qb->select('produtos')
             ->where('destaque', SqlOperator::EQUALS, true)
             ->cache(300)
             ->execute();

// Cache por 24 horas
$result = $qb->select('categorias')
             ->cache(86400)
             ->execute();

$result = $qb->select('pedidos')
             ->where('usuario_id', SqlOperator::EQUALS, $currentUserId)
             ->cache(3600)
             ->execute();

public function execute(bool $bufferedQuery = true): QueryResultDTO

class QueryResultDTO {
    public iterable $data;      // Resultados (array ou Generator)
    public int $count;          // Número de linhas afetadas
    public ?PaginationDTO $pagination;  // Dados de paginação (se limit usado)
}

$result = $qb->select('usuarios')->execute();

// Iterar resultados
foreach ($result->data as $usuario) {
    echo "{$usuario['nome']}\n";
}

// Informações
echo "Total: {$result->count} registros\n";

// Paginação (se usou limit)
if ($result->pagination) {
    echo "Página {$result->pagination->currentPage} de {$result->pagination->totalPages}\n";
    echo "Total de itens: {$result->pagination->totalItems}\n";
}

public function getQuerySql(): string

$sql = $qb->select('usuarios')
          ->where('ativo', SqlOperator::EQUALS, true)
          ->getQuerySql();

echo $sql;
// SELECT * FROM `usuarios` WHERE `ativo` = :param0

public function toSql(bool $withParams = false): string

$qb->select('usuarios')
   ->where('id', SqlOperator::EQUALS, 123)
   ->where('nome', SqlOperator::LIKE, '%João%');

// SQL com placeholders
echo $qb->toSql();
// SELECT * FROM `usuarios` WHERE `ativo` = :param0 AND `nome` LIKE :param1

// SQL com valores (apenas para debug!)
echo $qb->toSql(true);
// SELECT * FROM `usuarios` WHERE `ativo` = 123 AND `nome` LIKE '%João%'

public function explain(): array

$analysis = $qb->select('usuarios')
               ->join('pedidos', 'usuarios.id', '=', 'pedidos.usuario_id')
               ->where('usuarios.ativo', SqlOperator::EQUALS, true)
               ->explain();

print_r($analysis);
// [
//   ['id' => 1, 'select_type' => 'SIMPLE', 'table' => 'usuarios', 'type' => 'ALL', ...],
//   ['id' => 1, 'select_type' => 'SIMPLE', 'table' => 'pedidos', 'type' => 'ref', ...]
// ]

use Omegaalfa\QueryBuilder\enums\SqlOperator;
use Omegaalfa\QueryBuilder\enums\OrderDirection;

// CREATE
$qb->insert('produtos', [
    'nome' => 'Notebook Dell',
    'preco' => 3500.00,
    'estoque' => 10,
    'categoria_id' => 1,
    'ativo' => true
])->execute();

$produtoId = $qb->getInsertId();

// READ
$produto = $qb->select('produtos')
              ->where('id', SqlOperator::EQUALS, $produtoId)
              ->execute();

// UPDATE
$qb->update('produtos', ['preco' => 3200.00, 'estoque' => 8])
   ->where('id', SqlOperator::EQUALS, $produtoId)
   ->execute();

// DELETE
$qb->delete('produtos')
   ->where('id', SqlOperator::EQUALS, $produtoId)
   ->execute();

// Relatório de vendas por categoria
$result = $qb->select('categorias', [
    'categorias.nome as categoria',
    'COUNT(vendas.id) as total_vendas',
    'SUM(vendas.valor) as valor_total',
    'AVG(vendas.valor) as ticket_medio'
])
->join('produtos', 'categorias.id', '=', 'produtos.categoria_id')
->join('vendas', 'produtos.id', '=', 'vendas.produto_id')
->whereBetween('vendas.data', ['2024-01-01', '2024-12-31'])
->groupBy('categorias.id')
->having('total_vendas', SqlOperator::GREATER_THAN, 100)
->orderBy('valor_total', OrderDirection::DESC)
->execute();

foreach ($result->data as $row) {
    echo "{$row['categoria']}: ";
    echo "R$ " . number_format($row['valor_total'], 2) . " ";
    echo "({$row['total_vendas']} vendas)\n";
}

$page = $_GET['page'] ?? 1;
$perPage = 20;
$offset = ($page - 1) * $perPage;

$result = $qb->select('usuarios', ['id', 'nome', 'email', 'criado_em'])
             ->where('ativo', SqlOperator::EQUALS, true)
             ->orderBy('criado_em', OrderDirection::DESC)
             ->limit($perPage, $offset)
             ->execute();

// Exibir resultados
foreach ($result->data as $usuario) {
    echo "{$usuario['nome']} ({$usuario['email']})\n";
}

// Informações de paginação
$pg = $result->pagination;
echo "\nPágina {$pg->currentPage} de {$pg->totalPages}\n";
echo "Mostrando {$result->count} de {$pg->totalItems} usuários\n";

// Links de navegação
if ($pg->currentPage > 1) {
    echo "<a href='?page=" . ($pg->currentPage - 1) . "'>← Anterior</a> ";
}
if ($pg->currentPage < $pg->totalPages) {
    echo "<a href='?page=" . ($pg->currentPage + 1) . "'>Próxima →</a>";
}

try {
    $resultado = $qb->transactional(function($qb, $pdo) use ($usuarioId, $carrinho) {
        // 1. Criar pedido
        $qb->insert('pedidos', [
            'usuario_id' => $usuarioId,
            'status' => 'pendente',
            'total' => array_sum(array_column($carrinho, 'subtotal')),
            'criado_em' => new DateTime()
        ])->execute();
        
        $pedidoId = $qb->getInsertId();
        
        // 2. Adicionar itens do pedido
        $itens = [];
        foreach ($carrinho as $item) {
            $itens[] = [
                'pedido_id' => $pedidoId,
                'produto_id' => $item['produto_id'],
                'quantidade' => $item['quantidade'],
                'preco_unitario' => $item['preco'],
                'subtotal' => $item['subtotal']
            ];
        }
        $qb->insertBatch('itens_pedido', $itens)->execute();
        
        // 3. Atualizar estoque
        foreach ($carrinho as $item) {
            // Verificar estoque disponível
            $produto = $qb->select('produtos', ['estoque'])
                          ->where('id', SqlOperator::EQUALS, $item['produto_id'])
                          ->execute();
            
            $estoque = $produto->data[0]['estoque'];
            if ($estoque < $item['quantidade']) {
                throw new Exception("Estoque insuficiente para produto {$item['produto_id']}");
            }
            
            // Decrementar estoque
            $pdo->exec("
                UPDATE produtos 
                SET estoque = estoque - {$item['quantidade']}
                WHERE id = {$item['produto_id']}
            ");
        }
        
        // 4. Limpar carrinho
        $qb->delete('carrinho')
           ->where('usuario_id', SqlOperator::EQUALS, $usuarioId)
           ->execute();
        
        return $pedidoId;
    });
    
    echo "Pedido #{$resultado} criado com sucesso!";
    
} catch (Exception $e) {
    echo "Erro ao processar pedido: {$e->getMessage()}";
}

// Produtos mais vendidos do mês com informações de categoria
$result = $qb->raw('
    SELECT 
        p.id,
        p.nome,
        c.nome as categoria,
        p.preco,
        vendas.total_vendido,
        vendas.receita_total
    FROM produtos p
    INNER JOIN categorias c ON p.categoria_id = c.id
    INNER JOIN (
        SELECT 
            produto_id,
            SUM(quantidade) as total_vendido,
            SUM(subtotal) as receita_total
        FROM itens_pedido ip
        INNER JOIN pedidos ped ON ip.pedido_id = ped.id
        WHERE 
            ped.status = ? AND
            MONTH(ped.criado_em) = MONTH(CURRENT_DATE) AND
            YEAR(ped.criado_em) = YEAR(CURRENT_DATE)
        GROUP BY produto_id
    ) vendas ON p.id = vendas.produto_id
    ORDER BY vendas.receita_total DESC
    LIMIT 10
', ['concluido'])->execute();

foreach ($result->data as $produto) {
    echo "{$produto['nome']} ({$produto['categoria']})\n";
    echo "  Vendidos: {$produto['total_vendido']}\n";
    echo "  Receita: R$ " . number_format($produto['receita_total'], 2) . "\n\n";
}

// ✅ SEGURO - Valores sempre com prepared statements
$qb->where('email', SqlOperator::EQUALS, $_POST['email']);

// ✅ SEGURO - Whitelist para campos dinâmicos
$allowedFields = ['id', 'nome', 'email'];
$fields = array_intersect($_GET['fields'], $allowedFields);
$qb->select('usuarios', $fields);

// ⚠️ CUIDADO - O método select() agora aplica quoteIdentifier automaticamente,
// mas ainda é recomendado validar input de usuário para evitar erros de lógica.
$qb->select('usuarios', $_GET['fields']); 

Memória Peak para 1 Milhão de Registros

Omegaalfa (streaming):    ████████████████████ 32.02 MB
Laravel (cursor):                              ~0.00 MB*

* Valores medidos pelo script de benchmark