Comandos de Ponto

Você entrou no sqlite3, abriu o loja.db e fez consultas. Mas como saber quais tabelas existem ali? Quais colunas tem a tabela de produtos? E dá para a resposta sair numa tabela bonita, com o nome das colunas, em vez daquela fila de valores separados por |? Para isso o sqlite3 tem os comandos de ponto: .tables, .schema, .headers, .mode e outros. Eles não são SQL; são as ferramentas do próprio programa. Nesta aula você vai usar cada um no terminal da Ana, ver os erros mais comuns e aprender o jeito de fazer o mesmo no editor do guia, onde eles não existem.

Você vai aprender

O que é um comando de ponto e por que ele não é SQL.
.help e .show: a ajuda e as configurações atuais.
.tables: listar as tabelas do banco (e filtrar pelo nome).
.schema: ver como uma tabela foi criada, com as suas colunas.
.headers on e os modos de saída: .mode list, column, box, table, csv, line e markdown.
.nullvalue, .read e .databases.
As regras: começa na margem, sem ponto e vírgula, minúsculas.
Como ver as tabelas e as colunas em SQL, no editor do guia.

A ideia: os botões do balcão

Pense de novo no sqlite3 como o balcão do estoque. O SQL são os pedidos que você faz ao estoquista: "me traga os produtos com preço menor que 5". Os comandos de ponto são os botões do próprio balcão: "acenda a luz", "imprima em formato de tabela", "mostre a planta do depósito". Eles não mexem nos dados; mexem no programa: no que ele mostra e em como mostra.

	SQL	Comando de ponto
Exemplo	`SELECT nome FROM produtos;`	`.tables`
Quem entende	Todo banco: SQLite, MySQL, PostgreSQL…	Só o programa `sqlite3`
Como começa	Com uma palavra-chave (`SELECT`, `INSERT`…)	Com um ponto, na primeira coluna da linha
Como termina	Com `;`	No fim da linha, sem `;`
No editor do guia	Funciona	Não existe (dá erro)

Você já conhece três: .quit, .exit e .open, de O Terminal do SQLite. Agora vêm os outros. Todas as sessões abaixo começaram com sqlite3 loja.db, na pasta pessoal da Ana.

1. `.help`: a lista de comandos

O próprio sqlite3 avisa ao abrir: Enter ".help" for usage hints. O .help lista todos os comandos de ponto, um por linha, com uma frase em inglês. São muitos (no SQLite 3.50.4, a lista tem 66 linhas), e você vai usar poucos. Para ver a ajuda de um só, escreva o nome dele depois do .help:

sqlite> .help tables
.tables ?TABLE?          List names of tables matching LIKE pattern TABLE
sqlite> .help schema
.schema ?PATTERN?        Show the CREATE statements matching PATTERN
   Options:
      --indent             Try to pretty-print the schema
      --nosys              Omit objects whose names start with "sqlite_"
sqlite>

.tables ?TABLE?: O comando e o que ele aceita. O que está entre ? é opcional: você pode escrever só .tables ou .tables seguido de um nome.
List names of tables matching LIKE pattern TABLE: "Lista os nomes das tabelas que casam com o padrão TABLE", no estilo do LIKE (aula LIKE). Você vai usar isso na seção 2.
Options: --indent, --nosys: Opções extras do .schema. Não precisa delas agora.

Os que este guia usa, tirados da lista do .help (os textos em inglês são do próprio programa):

$ sqlite3 loja.db ".help" | grep -E "^\.(tables|schema|mode|headers|quit|exit|open|read|show|help|nullvalue|databases) "
.databases               List names and files of attached databases
.exit ?CODE?             Exit this program with return-code CODE
.headers on|off          Turn display of headers on or off
.help ?-all? ?PATTERN?   Show help text for PATTERN
.mode ?MODE? ?OPTIONS?   Set output mode
.nullvalue STRING        Use STRING in place of NULL values
.open ?OPTIONS? ?FILE?   Close existing database and reopen FILE
.quit                    Stop interpreting input stream, exit if primary.
.read FILE               Read input from FILE or command output
.schema ?PATTERN?        Show the CREATE statements matching PATTERN
.show                    Show the current values for various settings
.tables ?TABLE?          List names of tables matching LIKE pattern TABLE

(O grep do sistema filtrou a lista inteira para mostrar só essas linhas. Não se preocupe com ele.)

2. `.tables`: quais gavetas existem?

O comando que você mais vai usar ao abrir um banco que não conhece. Ele lista as tabelas em ordem alfabética, em colunas:

sqlite> .tables
categorias    fornecedores  itens_pedido  produtos
clientes      funcionarios  pedidos
sqlite>

As 7 tabelas da Loja Aurora. Leia de cima para baixo, coluna por coluna: categorias, clientes, fornecedores, funcionarios, itens_pedido, pedidos, produtos. É a "etiqueta das gavetas" do fichário: antes de pedir alguma coisa, você sabe o nome exato de cada uma (e evita o no such table: produto).

Com um padrão depois, o .tables filtra. O % quer dizer "qualquer coisa", como no LIKE:

$ sqlite3 loja.db ".tables p%"
pedidos   produtos
$ sqlite3 loja.db ".tables %pedido%"
itens_pedido  pedidos

"As tabelas que começam com p" e "as que têm pedido em algum lugar do nome". Repare que comandos de ponto também funcionam como argumento, entre aspas, igual ao SQL.

3. `.schema`: a planta de uma tabela

O .tables diz quais gavetas existem; o .schema mostra como cada uma foi montada: o comando CREATE TABLE que a criou, com todas as colunas. "Schema" quer dizer "esquema", a planta do banco.

sqlite> .schema produtos
CREATE TABLE produtos (
    id            INTEGER PRIMARY KEY,
    nome          TEXT NOT NULL,
    categoria_id  INTEGER NOT NULL REFERENCES categorias(id),
    fornecedor_id INTEGER NOT NULL REFERENCES fornecedores(id),
    preco         REAL NOT NULL,
    estoque       INTEGER NOT NULL DEFAULT 0,
    descontinuado INTEGER NOT NULL DEFAULT 0
);
sqlite>

Você ainda não aprendeu a criar tabelas, mas já dá para ler muita coisa:

CREATE TABLE produtos ( … );: "Crie a tabela produtos com estas colunas." Cada linha de dentro é uma coluna.
id INTEGER PRIMARY KEY: A coluna id, de números inteiros (INTEGER), é a chave primária: o número da ficha, que não se repete.
nome TEXT NOT NULL: O nome é texto (TEXT) e não pode ficar vazio (NOT NULL, "não nulo").
REFERENCES categorias(id): "Faz referência ao id da tabela categorias": é a ligação entre as gavetas que você viu em O que é um Banco de Dados.
preco REAL: O preço é um número com casas decimais (REAL).
DEFAULT 0: Se ninguém disser o estoque de um produto novo, ele começa com 0.

Cada uma dessas palavras tem aula própria no Nível 2 (CREATE TABLE, Os Tipos no SQLite, NOT NULL, DEFAULT, FOREIGN KEY). Por enquanto, use o .schema para descobrir os nomes das colunas antes de escrever um SELECT. Uma tabela menor, a de categorias:

sqlite> .schema categorias
CREATE TABLE categorias (
    id        INTEGER PRIMARY KEY,
    nome      TEXT NOT NULL,
    descricao TEXT
);
sqlite>

O .schema sozinho, sem nome, mostra a planta de todas as tabelas, uma depois da outra: bom para conhecer um banco novo de uma vez, mas é um texto comprido.

4. `.headers on`: o nome das colunas

Lembra que, no terminal, o resultado vem sem cabeçalho? O .headers on ("cabeçalhos ligados") resolve:

sqlite> SELECT id, nome, preco FROM produtos LIMIT 3;
1|Caderno Pautado 96 folhas|12.35
2|Caneta Esferográfica Azul|2.79
3|Lápis Grafite HB|1.15
sqlite> .headers on
sqlite> SELECT id, nome, preco FROM produtos LIMIT 3;
id|nome|preco
1|Caderno Pautado 96 folhas|12.35
2|Caneta Esferográfica Azul|2.79
3|Lápis Grafite HB|1.15
sqlite>

O .headers on não mostra nada: ele só muda a configuração, e vale para tudo o que vier depois, até você sair do programa ou digitar .headers off. A primeira linha do resultado agora diz o que é cada valor.

5. `.mode`: o formato da resposta

O .mode ("modo") escolhe como o resultado é desenhado. Os dados são os mesmos; muda a "embalagem". Aqui está a mesma consulta em cada modo, numa sessão só, com o .headers on da seção anterior ainda ligado:

`.mode column`: colunas alinhadas

sqlite> .mode column
sqlite> SELECT id, nome, preco FROM produtos LIMIT 3;
id  nome                       preco
--  -------------------------  -----
1   Caderno Pautado 96 folhas  12.35
2   Caneta Esferográfica Azul  2.79
3   Lápis Grafite HB           1.15
sqlite>

`.mode box`: uma tabela com linhas desenhadas

sqlite> .mode box
sqlite> SELECT id, nome, preco FROM produtos LIMIT 3;
┌────┬───────────────────────────┬───────┐
│ id │           nome            │ preco │
├────┼───────────────────────────┼───────┤
│ 1  │ Caderno Pautado 96 folhas │ 12.35 │
│ 2  │ Caneta Esferográfica Azul │ 2.79  │
│ 3  │ Lápis Grafite HB          │ 1.15  │
└────┴───────────────────────────┴───────┘
sqlite>

`.mode table`: a mesma tabela, só com `+`, `-` e `|`

sqlite> .mode table
sqlite> SELECT id, nome, preco FROM produtos LIMIT 3;
+----+---------------------------+-------+
| id |           nome            | preco |
+----+---------------------------+-------+
| 1  | Caderno Pautado 96 folhas | 12.35 |
| 2  | Caneta Esferográfica Azul | 2.79  |
| 3  | Lápis Grafite HB          | 1.15  |
+----+---------------------------+-------+
sqlite>

`.mode csv`: para abrir numa planilha

sqlite> .mode csv
sqlite> SELECT id, nome, preco FROM produtos LIMIT 3;
id,nome,preco
1,"Caderno Pautado 96 folhas",12.35
2,"Caneta Esferográfica Azul",2.79
3,"Lápis Grafite HB",1.15
sqlite>

`.mode line`: uma coluna por linha, como uma ficha

sqlite> .mode line
sqlite> SELECT id, nome, preco FROM produtos LIMIT 2;
   id = 1
 nome = Caderno Pautado 96 folhas
preco = 12.35

   id = 2
 nome = Caneta Esferográfica Azul
preco = 2.79
sqlite>

`.mode markdown`: para colar num documento

sqlite> .mode markdown
sqlite> SELECT id, nome, preco FROM produtos LIMIT 3;
| id |           nome            | preco |
|----|---------------------------|-------|
| 1  | Caderno Pautado 96 folhas | 12.35 |
| 2  | Caneta Esferográfica Azul | 2.79  |
| 3  | Lápis Grafite HB          | 1.15  |
sqlite>

`.mode list`: de volta ao padrão

sqlite> .mode list
sqlite> SELECT id, nome, preco FROM produtos LIMIT 3;
id|nome|preco
1|Caderno Pautado 96 folhas|12.35
2|Caneta Esferográfica Azul|2.79
3|Lápis Grafite HB|1.15
sqlite> .mode
current output mode: list --escape ascii
sqlite>

O .mode sozinho diz em que modo você está (o --escape ascii é um detalhe de como caracteres especiais são mostrados; pode ignorar).

Qual modo usar

Modo	Cara	Quando usar
`list` (padrão)	Valores separados por `\|`	Respostas curtas; scripts que leem a saída
`column`	Colunas alinhadas, cabeçalho sublinhado	Ler no terminal, sem enfeite
`box`	Tabela com linhas desenhadas	Estudar: é o mais fácil de ler, e o mais parecido com o editor do guia
`table`	Tabela com `+ - \|`	Como o box, para terminais ou textos que não mostram as linhas desenhadas
`csv`	Separado por vírgulas	Levar para uma planilha (aula Importar e Exportar CSV)
`line`	Uma coluna por linha	Linhas com muitas colunas, ou textos compridos
`markdown`	Tabela de Markdown	Colar em documentação, fóruns, README

Os modos que já trazem cabeçalho

O box, o table, o markdown e o column mostram o nome das colunas mesmo sem .headers on. Numa sessão nova, sem mexer em nada:

sqlite> .mode column
sqlite> SELECT id, nome FROM categorias LIMIT 2;
id  nome
--  -----------
1   Papelaria
2   Eletrônicos
sqlite>

E no box o cabeçalho aparece até com .headers off. O .headers faz diferença mesmo no list e no csv.

Experimente: no editor do guia o resultado já sai como uma tabela, parecida com o .mode box, e os comandos de ponto não existem. Rode a caixa e veja o erro do .mode box. Depois apague a primeira linha e rode de novo: a consulta dos três produtos, a mesma das sessões acima, aparece em forma de tabela.

.mode box
SELECT id, nome, preco FROM produtos LIMIT 3;

SELECT id, nome, preco FROM produtos LIMIT 3;

6. Outros três úteis: `.nullvalue`, `.read` e `.databases`

`.nullvalue`: deixar o NULL visível

O cliente 7 não tem email (o valor é NULL, "sem valor"). No terminal, o NULL aparece como um espaço em branco, fácil de confundir com um texto vazio. O .nullvalue escolhe uma palavra para ele:

sqlite> .mode box
sqlite> SELECT id, nome, email FROM clientes WHERE id BETWEEN 6 AND 8;
┌────┬───────────────────┬──────────────────────────────────┐
│ id │       nome        │              email               │
├────┼───────────────────┼──────────────────────────────────┤
│ 6  │ Rafael Monteiro   │ rafael.monteiro@exemplo.com.br   │
│ 7  │ Luís Otávio Brito │                                  │
│ 8  │ Fernanda Carvalho │ fernanda.carvalho@exemplo.com.br │
└────┴───────────────────┴──────────────────────────────────┘
sqlite> .nullvalue NULL
sqlite> SELECT id, nome, email FROM clientes WHERE id BETWEEN 6 AND 8;
┌────┬───────────────────┬──────────────────────────────────┐
│ id │       nome        │              email               │
├────┼───────────────────┼──────────────────────────────────┤
│ 6  │ Rafael Monteiro   │ rafael.monteiro@exemplo.com.br   │
│ 7  │ Luís Otávio Brito │ NULL                             │
│ 8  │ Fernanda Carvalho │ fernanda.carvalho@exemplo.com.br │
└────┴───────────────────┴──────────────────────────────────┘
sqlite>

No editor do guia, o NULL já aparece em itálico, sem precisar de nada. O NULL tem aula própria: O Valor NULL.

`.read`: rodar um arquivo de comandos

O .read lê um arquivo de SQL e executa tudo o que há nele, sem sair do programa. A Ana tinha um arquivo conta.sql com SELECT COUNT(*) FROM clientes; dentro:

sqlite> .read conta.sql
30
sqlite>

É o mesmo que sqlite3 loja.db < conta.sql, só que de dentro do sqlite3. No Windows, com o PowerShell, é o jeito de criar o banco da loja: .read aurora.sql (veja Instalar o SQLite).

`.databases`: qual arquivo está aberto?

sqlite> .databases
main: /home/ana/loja.db r/w
sqlite>

O banco principal (main) é o arquivo /home/ana/loja.db, aberto para leitura e escrita (r/w, de read/write). Útil quando você não lembra em qual banco está mexendo.

`.show`: todas as configurações

sqlite> .show
        echo: off
         eqp: off
     explain: auto
     headers: off
        mode: list
   nullvalue: ""
      output: stdout
colseparator: "|"
rowseparator: "\n"
       stats: off
       width:
    filename: loja.db
sqlite>

Numa sessão nova: cabeçalho desligado (headers: off), modo list, NULL mostrado como texto vazio (nullvalue: ""), separador |. Cada .headers, .mode e .nullvalue que você usar muda uma dessas linhas.

Sem entrar no programa: as opções da linha de comando

Vários modos também existem como opções do sqlite3, escritas antes do nome do banco. Para uma pergunta rápida já em tabela:

$ sqlite3 -box loja.db "SELECT id, nome FROM categorias LIMIT 2;"
┌────┬─────────────┐
│ id │    nome     │
├────┼─────────────┤
│ 1  │ Papelaria   │
│ 2  │ Eletrônicos │
└────┴─────────────┘
$ sqlite3 -header -csv loja.db "SELECT id, nome FROM categorias LIMIT 2;"
id,nome
1,Papelaria
2,"Eletrônicos"

Repare no CSV: o SQLite pôs aspas em "Eletrônicos", por causa da letra acentuada, mas não em Papelaria. As duas formas são CSV válido, e uma planilha lê as duas do mesmo jeito.

7. As regras dos comandos de ponto

O ponto fica na primeira coluna. Nada de espaço antes.
Sem ponto e vírgula. O comando termina no fim da linha.
Um por linha, e sozinho na linha: não dá para pôr um .tables depois de um SELECT.
Minúsculas. .tables funciona; .Tables, não.
Pode abreviar, desde que não fique ambíguo: .tab e .ta funcionam como .tables. Mas escreva o nome inteiro enquanto aprende.

Cada regra quebrada dá um erro diferente, todos em Quando dá errado.

8. E no editor do guia? Use SQL

O editor das aulas é o motor do SQLite, sem o programa sqlite3 em volta. Por isso ele não conhece nenhum comando de ponto:

.tables

Para o motor, aquilo é SQL, e SQL não começa com ponto: near ".": syntax error. Mas tudo o que o .tables e o .schema mostram está guardado no próprio banco, numa tabela especial chamada sqlite_schema, o "catálogo" do banco. E essa você pode consultar com SQL comum, em qualquer lugar:

SELECT name FROM sqlite_schema WHERE type = 'table' ORDER BY name;

sqlite_schema: A tabela-catálogo: uma linha para cada tabela (e índice, view…) do banco. Ela existe em todo banco SQLite, sem você criar.
name: A coluna com o nome de cada objeto. (Os nomes do catálogo são em inglês.)
WHERE type = 'table': Só as tabelas, sem os outros tipos de objeto.
ORDER BY name: Em ordem alfabética, como o .tables mostra (aula ORDER BY).

E a "planta" de uma tabela está na coluna sql do catálogo: é exatamente o texto que o .schema mostra.

SELECT sql FROM sqlite_schema WHERE name = 'categorias';

Um terceiro jeito, só com os nomes e os tipos das colunas, é o PRAGMA table_info. Um PRAGMA é um comando especial do SQLite para ler ou mudar configurações do banco (aula PRAGMAs Úteis):

PRAGMA table_info(produtos);

Uma linha por coluna: a posição (cid, começando do 0), o nome, o tipo, se é obrigatória (notnull = 1), o valor padrão (dflt_value) e se faz parte da chave primária (pk = 1).

Qual usar

Para	No terminal `sqlite3`	Em SQL (editor, programas, terminal)
Listar as tabelas	`.tables`	`SELECT name FROM sqlite_schema WHERE type = 'table';`
Ver como uma tabela foi criada	`.schema produtos`	`SELECT sql FROM sqlite_schema WHERE name = 'produtos';`
Só as colunas e os tipos	`.schema produtos` (e ler)	`PRAGMA table_info(produtos);`
Mudar o formato da resposta	`.mode`, `.headers`	Não existe: quem desenha é o programa (no editor, já sai em tabela)

Regra prática: no terminal, use os comandos de ponto, que são mais curtos. Num programa, ou no editor do guia, use as consultas.

Experimente: a Ana tentou o .tables no editor e deu erro. Troque pela consulta ao catálogo sqlite_schema, para listar os nomes das 7 tabelas da loja.

.tables

SELECT name FROM sqlite_schema WHERE type = 'table';

Nos outros bancos

Cada banco tem o seu jeito de mostrar as tabelas, e os comandos "de barra" ou "de ponto" são sempre do programa de terminal, não do SQL: no MySQL, SHOW TABLES; (que ali é um comando do próprio servidor); no PostgreSQL, \dt no terminal psql; no SQL Server, SELECT name FROM sys.tables;. Veja a tabela em Os Bancos Famosos. Nenhum deles roda no SQLite.

Quando dá errado

Todas as mensagens abaixo saíram do sqlite3 da Ana.

O ponto e vírgula no fim

sqlite> .tables;
Error: unknown command or invalid arguments:  "tables;". Enter ".help" for help
sqlite>

O que aconteceu: costume do SQL. O sqlite3 leu o comando como tables;, com o ponto e vírgula grudado, e não conhece nenhum comando com esse nome: "comando desconhecido ou argumentos inválidos".

Como consertar: .tables, sem ;.

Maiúscula

sqlite> .Tables
Error: unknown command or invalid arguments:  "Tables". Enter ".help" for help
sqlite>

O que aconteceu: no SQL, SELECT e select são iguais; nos comandos de ponto, não. Tables com T maiúsculo é outro nome.

Como consertar: comandos de ponto sempre em minúsculas: .tables.

Modo que não existe

sqlite> .mode boxx
Error: mode should be one of: ascii box column csv html insert json line list markdown qbox quote table tabs tcl
sqlite>

O que aconteceu: um x a mais. Aqui o erro é até útil: "o modo deve ser um destes", e vem a lista de todos os modos que o sqlite3 conhece. Além dos desta aula, há outros, como json e html.

Como consertar: .mode box.

Espaço antes do ponto

sqlite>   .tables
   ...> ;
Parse error: near ".": syntax error
  .tables ;
  ^--- error here
sqlite>

O que aconteceu: com espaços antes, o sqlite3 não reconhece o comando de ponto e acha que aquilo é o começo de um SQL. Mostra o prompt de continuação, espera o ; e, quando ele chega, o motor do SQLite reclama do ponto: o mesmo near ".": syntax error do editor do guia.

Como consertar: o ponto na primeira coluna da linha, sem nada antes.

Comando de ponto depois de um SQL, na mesma linha

sqlite> SELECT COUNT(*) FROM categorias; .tables
   ...> ;
8
Parse error: near ".": syntax error
  .tables ;
  ^--- error here
sqlite>

O que aconteceu: o SELECT rodou (as 8 categorias), mas o .tables não estava no começo da linha, então virou "mais SQL" e deu o mesmo erro do caso anterior.

Como consertar: um comando de ponto por linha, sozinho.

O .schema que não mostra nada

$ sqlite3 loja.db ".schema produto"
$

O que aconteceu: nenhum erro, nenhuma resposta. Não existe tabela chamada produto (é produtos), e o .schema, em vez de reclamar, simplesmente não acha nada para mostrar.

Como consertar: confira o nome com .tables e repita: .schema produtos. Moral: resposta vazia também é uma pista.

Referência rápida

Comando	O que faz
`.help`	Lista os comandos de ponto (`.help mode`: a ajuda de um só)
`.tables`	Lista as tabelas (`.tables p%`: as que começam com p)
`.schema tabela`	Mostra o `CREATE TABLE` da tabela (sem nome: de todas)
`.headers on` / `off`	Liga / desliga o nome das colunas no resultado
`.mode list`	Valores separados por `\|` (o padrão)
`.mode column`	Colunas alinhadas
`.mode box`	Tabela com linhas desenhadas
`.mode table`	Tabela com `+ - \|`
`.mode csv`	Separado por vírgulas, para planilhas
`.mode line`	Uma coluna por linha
`.mode markdown`	Tabela de Markdown
`.mode`	Mostra o modo atual
`.nullvalue TEXTO`	Mostra o NULL com esse texto
`.read arquivo.sql`	Executa os comandos de um arquivo
`.databases`	Mostra qual arquivo de banco está aberto
`.show`	Mostra as configurações atuais
`.open arquivo.db`	Abre outro banco
`.quit` / `.exit`	Sai do `sqlite3`

A lista completa, com todos os comandos de ponto, está na referência Comandos de Ponto do sqlite3.

Exercícios

1. As gavetas

Complete o comando de ponto que lista as tabelas do banco:

sqlite> .

2. O formato de tabela

Complete para o resultado sair numa tabela com linhas desenhadas:

sqlite> .mode

3. A Ana digitou .tables; e recebeu Error: unknown command or invalid arguments. Por quê?

O banco não tem tabelas Faltou abrir o banco com .open Comandos de ponto não levam ponto e vírgula O comando certo é .TABLES

4. A Ana quer saber quais colunas tem a tabela pedidos, no terminal. Qual comando?

.tables pedidos .schema pedidos .mode pedidos .headers pedidos

5. No editor do guia, .tables dá near ".": syntax error. Como listar as tabelas ali?

Não tem como SHOW TABLES; .tables; SELECT name FROM sqlite_schema WHERE type = 'table';

6. Para levar o resultado de uma consulta para uma planilha, qual modo combina mais?

.mode csv .mode line .mode box .mode list

Missão final: a planta dos produtos, em SQL

Missão: no terminal, a Ana veria a planta da tabela de produtos com .schema produtos. No editor, isso se faz pelo catálogo. A consulta abaixo mostra a planta da tabela categorias; mude-a para mostrar a da tabela produtos. Confira no resultado: a última coluna da tabela de produtos é a que diz se o produto saiu de linha.

SELECT sql FROM sqlite_schema WHERE name = 'categorias';

SELECT sql FROM sqlite_schema WHERE name = 'produtos';

Quer as colunas uma por linha? Tente também PRAGMA table_info(produtos); na mesma caixa.

Resumo

Comandos de ponto são do programa sqlite3, não do SQL: mudam o que o programa mostra, não os dados. No editor do guia eles não existem (near ".": syntax error).
.tables lista as tabelas; .schema tabela mostra como ela foi criada, com as colunas; .help lista os comandos.
.headers on liga o nome das colunas. .mode escolhe o formato: list (padrão), column, box, table, csv, line, markdown. O box é o melhor para estudar.
.nullvalue NULL deixa o NULL visível; .read roda um arquivo; .databases mostra o arquivo aberto; .show mostra as configurações.
As regras: o ponto na primeira coluna, sem ;, um por linha, em minúsculas.
Em SQL, em qualquer lugar: SELECT name FROM sqlite_schema WHERE type = 'table' (as tabelas), SELECT sql FROM sqlite_schema WHERE name = '…' (a planta) e PRAGMA table_info(…) (as colunas).

Comandos de Ponto

A ideia: os botões do balcão

1. .help: a lista de comandos

2. .tables: quais gavetas existem?

3. .schema: a planta de uma tabela

4. .headers on: o nome das colunas

5. .mode: o formato da resposta

.mode column: colunas alinhadas

.mode box: uma tabela com linhas desenhadas

.mode table: a mesma tabela, só com +, - e |

.mode csv: para abrir numa planilha

.mode line: uma coluna por linha, como uma ficha

.mode markdown: para colar num documento

.mode list: de volta ao padrão