Exportar

funcional

Enviar los resultados en el formato que la siguiente persona o herramienta aprovechará de verdad.

Uno Exportar… comando, desde el menú de la cuadrícula o la barra de herramientas, abre un único diálogo para cualquier conjunto de resultados. Elige un formato, selecciona Copiar al portapapeles o Guardar en archivo…, y listo. Los formatos de datos estándar y los generadores para lenguajes de programación conviven, y los formatos sin usar se pueden ocultar en Ajustes › Resultados › Exportar.

SQLly
Diálogo de exportación de resultados de SQLlyDiálogo de exportación de resultados de SQLly
El diálogo de Exportación consolidado: lista de formatos agrupados en Estándar y Programación, con destinos de portapapeles/archivo.
Opciones de exportación compartidas - también bajo Ajustes › Resultados › Exportar, aplicar a todos los formatos: cómo NULL se escribe, cómo se manejan los saltos de línea de las celdas, si se incluyen encabezados, el gzip opcional y el patrón del nombre de archivo por lotes {schema}_{table}_{date}.{format}.
Valores muy largos. La cuadrícula obtiene como vista previa de 8 KiB cualquier celda de texto o binaria de más de 8 KiB (el valor completo se lee bajo demanda al abrirla). Las exportaciones desde la cuadrícula (este diálogo, Copiar como, Guardar resultados y Abrir en hoja de cálculo) escriben las filas que la cuadrícula contiene, así que esas celdas se exportan como sus vistas previas, y Mensajes indica cuántas celdas se ven afectadas. Las exportaciones que ejecutan la consulta por sí mismas escriben cada valor completo: Exportar tablas… y Guardar datos como en el explorador, exportaciones de consultas programadas, Exportar base de datos como SQL, transferencias de datos, y sqlly query en la línea de comandos. Por una conexión de relé, lo mismo se aplica en cuanto el puente ejecute esta versión; un puente más antiguo envía cada celda entera, así que la cuadrícula no tiene vistas previas que mostrar y una sola fila de más de 16 MiB hace fallar la consulta.
Resultados muy grandes. Un resultado demasiado grande para mantenerse en memoria se guarda en disco. Exportarlo o copiarlo lee sus primeras 100.000 filas del disco en segundo plano (una nota encima de la cuadrícula indica qué se está leyendo) y luego completa la exportación; Mensajes avisa si se dejaron fuera filas más allá de ese punto. Instantáneas, el panel de Perfil, Transponer y mover la pestaña a otra ventana lo leen de la misma manera.

Todos los ejemplos de abajo exportan este pequeño conjunto de resultados de dos filas:

SELECT id, customer, amount, created FROM orders;
-- id | customer | amount  | created
--  1 | Acme     | 1250.00 | 2026-09-01
--  2 | Globex   |  890.50 | 2026-09-02

Formatos estándar

CSV .csv

Separado por comas, con comillas al estilo RFC. Una variante compatible con Excel añade un BOM UTF-8.

id,customer,amount,created
1,Acme,1250.00,2026-09-01
2,Globex,890.50,2026-09-02

TSV .tsv

Separado por tabulaciones: fácil de pegar en hojas de cálculo.

id	customer	amount	created
1	Acme	1250.00	2026-09-01
2	Globex	890.50	2026-09-02

JSON .json

Un arreglo de objetos, uno por fila.

[
  { "id": 1, "customer": "Acme", "amount": 1250.00, "created": "2026-09-01" },
  { "id": 2, "customer": "Globex", "amount": 890.50, "created": "2026-09-02" }
]

JSON Lines .jsonl

Un objeto JSON por línea, ideal para streaming y para pipelines de registros.

{"id":1,"customer":"Acme","amount":1250.00,"created":"2026-09-01"}
{"id":2,"customer":"Globex","amount":890.50,"created":"2026-09-02"}

Markdown .md

Una tabla con barras verticales y una fila separadora; las barras dentro de las celdas se escapan.

| id | customer | amount  | created    |
| -- | -------- | ------- | ---------- |
| 1  | Acme     | 1250.00 | 2026-09-01 |
| 2  | Globex   | 890.50  | 2026-09-02 |

HTML .html

Independiente <table>.

<table>
  <thead><tr><th>id</th><th>customer</th><th>amount</th><th>created</th></tr></thead>
  <tbody>
    <tr><td>1</td><td>Acme</td><td>1250.00</td><td>2026-09-01</td></tr>
    <tr><td>2</td><td>Globex</td><td>890.50</td><td>2026-09-02</td></tr>
  </tbody>
</table>

XML .xml

Un documento con una fila por elemento.

<rows>
  <row>
    <id>1</id>
    <customer>Acme</customer>
    <amount>1250.00</amount>
    <created>2026-09-01</created>
  </row>
  <row>
    <id>2</id>
    <customer>Globex</customer>
    <amount>890.50</amount>
    <created>2026-09-02</created>
  </row>
</rows>

INSERT .sql

INSERT instrucciones, entrecomilladas según el dialecto de tu conexión ([brackets] en SQL Server, comillas invertidas en MySQL y ClickHouse, comillas dobles en PostgreSQL, SQLite, DuckDB y Oracle), con los literales representados como los espera ese motor.

INSERT INTO orders (id, customer, amount, created) VALUES
  (1, 'Acme', 1250.00, '2026-09-01'),
  (2, 'Globex', 890.50, '2026-09-02');

Tabla temporal .sql

A CREATE para una tabla temporal más los inserts: una instantánea autónoma que puedes pegar en otra sesión. Con soporte de dialecto.

CREATE TABLE #orders (
  id        INT,
  customer  NVARCHAR(4000),
  amount    DECIMAL(18,2),
  created   DATE
);
INSERT INTO #orders (id, customer, amount, created) VALUES
  (1, 'Acme', 1250.00, '2026-09-01'),
  (2, 'Globex', 890.50, '2026-09-02');

Valores SQL .sql

Una lista simple VALUES lista para colocar en un CTE o IN cláusula. Consciente del dialecto.

VALUES
  (1, 'Acme', 1250.00, '2026-09-01'),
  (2, 'Globex', 890.50, '2026-09-02')

Excel (XLSX) .xlsx

Un verdadero .xlsx libro de trabajo, una tabla de Excel formateada con filas alternadas y un encabezado con filtro automático. Mantiene la cuadrícula tal como la ves: orden de columnas, anchos, columnas ocultas y congeladas, formatos de números y fechas, y formato condicional. Las columnas calculadas se convierten en fórmulas de Excel activas, y una tabla dinámica configurada obtiene una segunda hoja. Como es binario, este formato se guarda en un archivo (el portapapeles está deshabilitado para él). Los detalles están en Exportación a Excel.

Exportación de SQLLY .sqllyexport

Formato propio de SQLly: lleva las filas junto con sus tipos de columnas y metadatos, para que los datos vuelvan a SQLly sin pérdidas.

Formatos de programación

Estos generadores producen código fuente listo para pegar, con las filas de resultados incrustadas como datos, útil para fixtures, datos iniciales y scripts rápidos. Un ejemplo por lenguaje:

C# .cs

var rows = new[]
{
    new { Id = 1, Customer = "Acme", Amount = 1250.00m, Created = "2026-09-01" },
    new { Id = 2, Customer = "Globex", Amount = 890.50m, Created = "2026-09-02" },
};

Python .py

rows = [
    {"id": 1, "customer": "Acme", "amount": 1250.00, "created": "2026-09-01"},
    {"id": 2, "customer": "Globex", "amount": 890.50, "created": "2026-09-02"},
]

Rust .rs

struct Order { id: i64, customer: &'static str, amount: f64, created: &'static str }

let rows = vec![
    Order { id: 1, customer: "Acme", amount: 1250.00, created: "2026-09-01" },
    Order { id: 2, customer: "Globex", amount: 890.50, created: "2026-09-02" },
];

JavaScript .js

const rows = [
  { id: 1, customer: "Acme", amount: 1250.00, created: "2026-09-01" },
  { id: 2, customer: "Globex", amount: 890.50, created: "2026-09-02" },
];

TypeScript .ts

interface Order { id: number; customer: string; amount: number; created: string; }

const rows: Order[] = [
  { id: 1, customer: "Acme", amount: 1250.00, created: "2026-09-01" },
  { id: 2, customer: "Globex", amount: 890.50, created: "2026-09-02" },
];

Kotlin .kt

data class Order(val id: Int, val customer: String, val amount: Double, val created: String)

val rows = listOf(
    Order(1, "Acme", 1250.00, "2026-09-01"),
    Order(2, "Globex", 890.50, "2026-09-02"),
)

Swift .swift

struct Order { let id: Int; let customer: String; let amount: Double; let created: String }

let rows = [
    Order(id: 1, customer: "Acme", amount: 1250.00, created: "2026-09-01"),
    Order(id: 2, customer: "Globex", amount: 890.50, created: "2026-09-02"),
]

Java .java

record Order(int id, String customer, double amount, String created) {}

List<Order> rows = List.of(
    new Order(1, "Acme", 1250.00, "2026-09-01"),
    new Order(2, "Globex", 890.50, "2026-09-02")
);

Go .go

type Order struct {
    ID       int
    Customer string
    Amount   float64
    Created  string
}

rows := []Order{
    {1, "Acme", 1250.00, "2026-09-01"},
    {2, "Globex", 890.50, "2026-09-02"},
}

PHP .php

$rows = [
    ['id' => 1, 'customer' => 'Acme', 'amount' => 1250.00, 'created' => '2026-09-01'],
    ['id' => 2, 'customer' => 'Globex', 'amount' => 890.50, 'created' => '2026-09-02'],
];

C++ .cpp

struct Order { int id; std::string customer; double amount; std::string created; };

std::vector<Order> rows = {
    {1, "Acme", 1250.00, "2026-09-01"},
    {2, "Globex", 890.50, "2026-09-02"},
};

Los nombres exactos de los campos, los tipos y el entrecomillado de los valores siguen las columnas del resultado y el dialecto de tu conexión; los ejemplos anteriores son representativos. Cualquier formato que no uses se puede ocultar en Ajustes › Resultados › Exportar.