Controle de Versão

• SVN Cheat Sheet
• Git Cheat Sheet
• Mercurial Cheat Sheet
• Bazaar Cheat Sheet

Frameworks

• Prototype Cheat Sheet
• MooTools Cheat Sheet
• jQuery Cheat Sheet
• Ruby On Rails
• Django Cheat Sheet
• CodeIgniter Cheat Sheet
• CakePHP Cheat Sheet
• Mais de 12 Symfony Cheat Sheets

Programação

• Bash Script Quick Refences
• AWK Cheat Sheet
• HTML5 Canvas Cheat Sheet
• PHP Cheat Sheet
• Ruby Quick Refence
• 9 Perl Cheat Sheets
• Python Quick Refence
• Regular Expression Cheat Sheet

Web Design

• Font Size Cheat Sheet
• Propriedades CSS
• HTML Char Entities Cheat Sheet
• 6 Design Colors Cheat Sheet
• SEO Web Developer Cheat Sheet

Bancos de Dados

• XML Schema Structure Quick Refence
• MySQL Cheat Sheet
• PostgreSQL Cheat Sheet

Ferramentas

• Google Search Cheat Sheet
• Firebug Cheat Sheet
• Vimperator Cheat Sheet
• LaTeX Cheat Sheet
• Vim Cheat Sheet
• Vim Quick Refence
• mod_rewirte Cheat Sheet

Alguma que eu tenha esquecido? Posta ae nos comentários!

Parece radical, mas a produtividade aumenta, de certo modo. Não só na hora de programar e testar, sempre que edito arquivos no Vim, tento não usar o mouse. Claro que sempre vai ter alguma aplicação que vai te obrigar a usar o mouse, mas se pudermos evitar, melhor!

Eu continuo com esta idéia. Coisinha bonita é para cliente final. Desenvolvedores devem trabalhar com ferramentas que proporcionam o melhor uso do tempo possível, pois o bom profissional é aquele que esbanja do ócio, eis o fluxo:

• Concluir as atividades rapidamente com eficácia e eficiência está diretamente ligado ao ócio, pois se ele tivesse feito algo mal feito, estaria corrigindo os bugs e não vendo vídeos no youtube.
• Com tempo livre, o cérebro humano fica mais descansado e mais propício a receber insights/intuições para resolver problemas difíceis, que – e estes merecem – precisam de mais tempo e necessitam ser bem planejados.
• Resolvendo problemas de forma criativa – talvez até inovadora -, faz com que se evite problemas futuros. Logo, se poupa tempo. Se poupando tempo, voltamos a cláusula anterior.

Parece utópico, mas eu acredito nisso. Eu acho que é possível. Basta saber onde conseguir ganhar tempo em atividades, automatizando com scripts, programas e etc, o tempo é consequência.

Todo Desenvolvedor Web já foi ou ainda é DBA. É inevitável aprender a utilizar banco de dados sem modelar os dados. Geralmente, para isso, é utilizado alguma ferramente gráfica que auxilia na visão do modelo. Não vou citar, mas existem várias para isso.

Porém, há um detalhe que muitos não se atinaram ainda. Me dei conta disso assistindo uma palestra no FISL10, na palestra do Leandro Dutra (se for parente, é primo de muitos graus :S) chamada O elefante ilustrado: modelagem literária e documentação automática em PostgreSQL e outros SGBDs livres.

SchemaSpy

O que é?

É uma ferramente que varre um banco de dados e gera um documentação em HTML nevegável. Ela gera gráfico de chaves estrangeiras utilizando o GraphViz (.dot), como se fosse uma dessas ferramentas que terminam com Designer.

Esses gráficos gerados, são visivelmente bonitos e dispostos. Ou seja, não é mais necessário sofrer arrastando caixinhas de modo com que fique bem arrumado. O programa tem um bom algoritmo para organizar. O que possibilita que o DBA, ou o desenvolvedor mesmo, use este tempo para repensar uma constraint, uma foreign key, etc.

O HTML gerado também tem abas que diferenciam os conteúdos: abas para relacionamentos, abas para tabelas auxiliares, abas para listagem de colunas/tabelas, etc. Mostra os campos, o tipo dos campos, os comentários, valores em comum e as CONSTRAINTS. Ou seja, uma solução completa para documentação de bancos de dados e modelos de ER. Vem junto o jQuery, que da uns efeitos e toggleia algumas colunas das tabelas de exibição.

Onde conseguir?

O site oficial deles é http://schemaspy.sourceforge.net. Pode ser baixado de lá. Apenas o driver jdbc para o banco de dados que for ser usado deve ser encontrado separadamente.

Quem usa ArchLinux, pode baixar os repositórios do AUR. Eu mesmo sou o mantenedor do pacote, então, qualquer dúvida ou problema, comente lá que tentarei responder/resolver o mais rápido possível. O link do repositório é http://aur.archlinux.org/packages.php?ID=28022

Como usar?

Para usar é muito simples. Depois de baixar o .jar, apenas execute

$ java -jar /path/to/schemaSpy.jar --help

Ou, se você instalou o do repositório do ArchLinux, basta usar:

$ schemaspy --help

Ele vai listar os parâmetros, é bem simples. Não vou me deter a isso. Qualquer dúvida comente no post abaixo.

Um exemplo de output pode ser encontrado na própria página do SchemaSpy: http://schemaspy.sourceforge.net/sample/

Sugestoẽs

Se existe algum defeito nele, com certeza é o template. O HTML gerado não é o mais bonito. Não obstante, me parece que o template não é customizável, para isso seria necessário hackear a classe que gera o template. Mas, quem sabe não é implementado algo nas próximas versões? Quem sabe VOCÊ não implementa?

Mas bem, falando em sugestões, aqui vai algumas:

• Integrar com a documentação do phpDocumentor, javaDoc ou outro similar.
• Versionar a documentação gerada para avaliação de crescimento da aplicação: poder comparar como era há certo tempo atrás e como está hoje.
• Programar os SQL’s utilizando algum editor de texto, fazendo você ganhar desempenho e analisar mais facilmente para comentários, constraints, triggers, procedures e views, que são geralmente mais complexas de serem vistas em programas gráficos.

Mais alguma sugestão? Críticas? Deixem nos posts abaixo!

O que é Adapter Pattern?

Bom, imaginemos aqueles cartões de memória de máquina fotográfica. Existem de várias tamanhos, micro, pequenos, grandes, gigantes. Seria realmente uma merda se uma máquina fotográfica suportasse somente 1 tamanho, por isso foi inventada aqueles… adivinhem… adaptadores que permitem que micros e pequenos caibam em grande, por exemplo. Todos tem a mesma finalidade, porém, têm tamanhos diferentes.Para isso serve o Adapter Pattern, para resolver justamente esse tipo de problema.

Quando se fala em abstração, geralmente se fala em Adapter Pattern, justamente por isso, porque ele te permite, com um mesmo objeto, fazer ações diferentes com uma finalidade em comum.

Para entendermos melhor, pensemos no caso de abstração de banco de dados. A sintaxe de cada um é diferente, porém têm as mesmas claúsulas. Alguns permitem transações, outros não. Pois esta é uma situação perfeita para o Adapter Pattern. Mas seria muito complexo explicar utilizando ela como exemplo, logo, fiz um exemplo em python que vai ajudar.

class ShapeAbstract(object):
 
	def countCorner(self):
		return self.corners
 
	def __str__(self):
		return self.name
 
	def area(self): abstract
 
class SquareShape(ShapeAbstract):
	def __init__(self, x, y=None):
		self.corners = 4
		self.name = 'Square'
		if (x is not None):
			self.l = x
 
	def area(self):
		return self.l*self.l
 
class TriangleShape(ShapeAbstract):
	def __init__(self, x, y):
		self.corners = 3
		self.name = 'Triangle'
		self.x = x
		self.y = y
 
	def area(self):
		return ((self.x*self.y)/2)

Bom, Tudo começa na nossa classe abstrata ShapeAbstract. Ela é a classe que vai servir de base para todos as formas que vamos calcular a área. Temos a classe SquareShape que representa um quadrado (jura? :/). O construtor da classe, __init__, recebe 2 valores: altura e a largura. Visto que é um quadrado, todos os lados são iguais, não é necessário passar a altura, ficamos somente com a largura. O que difere do triângulo, cujas medidas são base e altura. A nomenclatura não importa, no caso, vamos utilizar no máximo 2 medidas.

Nosso adapter é simplório, caso houvesse a necessidade de calcular a área de um trapésio, seria necessário mais um parâmetro, afinal, a fórmula é: ((base maior + base menor) / 2 * altura). Isso é facilmente implantado utilizando apenas mais um parâmetro no __init__, porque o que realmente queremos é fazer com que o método area() nos retorne a área.

import Shapes
 
class Shape(object):
 
	def setAdapter(self, Adapter):
		self.Adapter = Adapter
 
	def countCorner(self):
		return self.Adapter.countCorner()
 
	def area(self):
		return self.Adapter.area()
 
	def __str__(self):
		return self.Adapter.__str__();
 
	def newShape(ShapeAdapter):
		shape = Shape()
		shape.setAdapter(ShapeAdapter)
		return shape
 
	newShape = staticmethod(newShape)
 
if __name__ == '__main__':
	shape = Shape.newShape(Shapes.SquareShape(5))
	print shape
	print shape.countCorner()
	print shape.area()
        #Imprime:
        #Square
        #4
        #25
 
	shape = Shape.newShape(Shapes.TriangleShape(5,6))
	print shape
	print shape.countCorner()
	print shape.area()
        #Imprime:
        #Triangle
        #3
        #15

Nesta “aplicação principal” vemos a real classe adaptativa: Shape. Ela recebe a instância da classe e executa os métodos dela. Parece bobo ter uma classe que executa o método de outra classe, mas é fundamental para o reuso e a famosa abstração.

Vejam que elas se comportam diferentes. Claro, são formas diferentes! Áreas diferentes! Número de cantos diferentes! E nomes direfentes!

Agora fica fácil ver esse exemplo abstraindo, por exemplo, um banco de dados? Pense que a classe Shape seja Database, TriangleShape seja MySQLDatabase e SquareShape seja MSSQLDatabase, o método area() seja o método setLimit().

shape = Database(MySQLDatabase())
print shape.setLimit(5);
#Imprimi: LIMIT 5
shape = Database(MSSQLDatabase())
print shape.setLimit(5);
#Imprimi: TOP 5

Usando Adapter para 3rd part

Uma das minhas sugestões de uso do Adapter Pattern é com integração de código de terceiros. Vamos supor que você tenha 3 bibliotecas que geram gráficos: X, Y e Z. A bilioteca X é muito boa, mas não tem gráficos em pizza, que na Y tem. Mas a Z, por sua vez, tem gráficos em pizza em 3d. Vamos analizar a situação:

• A responsabilidade é a mesma: gerar um gráfico.
• Independente do tipo de gráfico (com barras, pizza, etc), todas elas vão receber os mesmos tipos de dados.
• Cada biblioteca tem seus próprios métodos, com nomes diferentes, mas para as mesma finalidade

Não parece um lugar perfeito para se utilizar o Adapter Pattern? Ora, vamos fazer um pequeno esboço:

graph = GraphAdapter()
graph.setData(([20,30,10],[15,25,35]))
graph.desenhaGrafico(GRAFICOS.BARRA)
graph.desenhaGrafico(GRAFICOS.PIZZA)
graph.desenhaGrafico(GRAFICOS.PIZZA3D)

Observem que não utilizei a instância de uma classe como adapter, utilizei constantes que vão determinar, na hora de desenhar o gráfico, o tipo dele. Se for BARRA, faz justamente como a biblioteca X exige, usando a API dela. O mesmo para PIZZA (Y) e PIZZA3D (Z). Pronto! Você, utilizando patterns, terá seu próprio modo de gerar gráficos, mesmo que com bibliotecas diferentes! Comentem e até a próxima!

Os poucos que já me conhecem, sabem que sou fã do GVim. Nem Vi nem Vim. Sempre escuto pessoas falando de outros editores, como o bluefish, notepad++, emacs. Mas, eu sou cabeça-dura, ranzinza mesmo. Então vou fazer um série de posts mostrando umas coisas divertidas de se fazer usando o GVim para facilitar a vida e acelerar o desenvolvimento. São coisas pequenas mas, que às vezes, consomem um bom tempo e enchem o saco.

Começando por criar uma SQL de INSERT numa tabela que tenha muitas colunas. No exemplo abaixo, vou usar o PHP e MySQL para fazer, porém, é só adaptar pra outras linguagens.

Bom, vamos começar do começo:

Listando as colunas.

Vamos imaginar uma tabela do banco de dados que tenha muitas colunas. Como exemplo, vou usar uma própria do wordpress, que é responsável pelo armazenamento dos posts. A idéia do post não é ensinar expressão regular, mas sim mostrar como utilizá-la no GVim e mostrar o seu real poder.

Criando à partir do terminal:

Bom, tudo começa no conhecido terminal. Digitamos:

# mysql -uUSER -pSENHA DATABASE -e “describe TABLE;” #No meu caso usei a tabela de posts wordpress

+-----------------------+---------------------+------+-----+---------------------+----------------+
| Field                 | Type                | Null | Key | Default             | Extra          |
+-----------------------+---------------------+------+-----+---------------------+----------------+
| ID                    | bigint(20) unsigned | NO   | PRI | NULL                | auto_increment |
| post_author           | bigint(20)          | NO   |     | 0                   |                |
| post_date             | datetime            | NO   |     | 0000-00-00 00:00:00 |                |
| post_date_gmt         | datetime            | NO   |     | 0000-00-00 00:00:00 |                |
| post_content          | longtext            | NO   |     | NULL                |                |
| post_title            | text                | NO   |     | NULL                |                |
| post_category         | int(4)              | NO   |     | 0                   |                |
| post_excerpt          | text                | NO   |     | NULL                |                |
| post_status           | varchar(20)         | NO   |     | publish             |                |
| comment_status        | varchar(20)         | NO   |     | open                |                |
| ping_status           | varchar(20)         | NO   |     | open                |                |
| post_password         | varchar(20)         | NO   |     |                     |                |
| post_name             | varchar(200)        | NO   | MUL |                     |                |
| to_ping               | text                | NO   |     | NULL                |                |
| pinged                | text                | NO   |     | NULL                |                |
| post_modified         | datetime            | NO   |     | 0000-00-00 00:00:00 |                |
| post_modified_gmt     | datetime            | NO   |     | 0000-00-00 00:00:00 |                |
| post_content_filtered | text                | NO   |     | NULL                |                |
| post_parent           | bigint(20)          | NO   | MUL | 0                   |                |
| guid                  | varchar(255)        | NO   |     |                     |                |
| menu_order            | int(11)             | NO   |     | 0                   |                |
| post_type             | varchar(20)         | NO   | MUL | post                |                |
| post_mime_type        | varchar(100)        | NO   |     |                     |                |
| comment_count         | bigint(20)          | NO   |     | 0                   |                |
+-----------------------+---------------------+------+-----+---------------------+----------------+

Deve aparecer algo parecido com isso para você. Bom, para facilitar, apagamos manualmente as 3 primeras linhas e a última. Ou, se quiser fazer pelo gvim digitando:

:1,3g/^./d
:$g/^./d

Bom, o comando g, vai fazer um busca e, logo após, executa um comando. No nosso caso as três primeiras linhas que contenham pelo menos 1 caracter e a última linha do arquivo.

Jogando o lixo no lixo

:%s/^|\s*\([^ ]*\).*/\1/g

Você obterá algo assim:

ID
post_author
post_date
post_date_gmt
post_content
post_title
post_category
post_excerpt
post_status
comment_status
ping_status
post_password
post_name
to_ping
pinged
post_modified
post_modified_gmt
post_content_filtered
post_parent
guid
menu_order
post_type
post_mime_type
comment_count

“It’s like magic!” Wow. Sim. Usamos o %s, que substitui no arquivo inteiro. Notem que é necessário escapar os parênteses para criar grupos em expressão regular. Isso é devido a utilidade do GVim. Em um editor cuja finalidade é facilitar a vida na programação, não teria sentido ao contrário. Afinal, procurar por um if ( ou um while () é muito comum. E ter que ficar escapando tudo, ia ser um saco! Bom, uma explicação melhor:

• %s -> substitui em todo arquivo.
• /^|\s*\([^ ]*\).*/ -> Começa com | pode ter espaços (captura tudo que não for espaços) o resto da linha que não nos interessa.
• \1/g -> \1 Faz uma referência ao primeiro grupo capturado na expressão anterior, no caso (tudo que não for espaço). O g é para que pudesse casar mais de uma vez. Neste caso não é necessário (força do hábito).

Notem que é necessário aquele .* do final, pois a expressão que casar, é a expressão substituída. E não somente o que estiver entre os grupos. Colocando o que queremos manter no grupo (no caso o nome da coluna) e substituimos a linha inteira pelo nome da coluna.

Juntando numa única linha

Bom, agora é simples! Para montarmos a SQL precisamos juntar elas em 1 linha só. Para isso, olhamos o número de linhas que tem no arquivo e, no modo normal, com o ponteiro na primeira coluna da primeira linha (pra ter certeza pode ser digitado gg), digitamos:

(NUMERO_DE_LINHAS)J – Por exemplo: O arquivo tem 24 linhas, então será digitado: 24J. Tendo elas em uma só linha, basta substituir os espaços por vírgula:

%s/\s/, /g

Colocar o digitado entre parênteses e depois digitar: yypp. Agora temos duas linhas iguais, assim:

(ID, post_author, post_date, post_date_gmt, post_content, post_title, post_category, post_excerpt, post_status, comment_status, ping_status, post_password, post_name, to_ping, pinged, post_modified, post_modified_gmt, post_content_filtered, post_parent, guid, menu_order, post_type, post_mime_type, comment_count)
(ID, post_author, post_date, post_date_gmt, post_content, post_title, post_category, post_excerpt, post_status, comment_status, ping_status, post_password, post_name, to_ping, pinged, post_modified, post_modified_gmt, post_content_filtered, post_parent, guid, menu_order, post_type, post_mime_type, comment_count)
(ID, post_author, post_date, post_date_gmt, post_content, post_title, post_category, post_excerpt, post_status, comment_status, ping_status, post_password, post_name, to_ping, pinged, post_modified, post_modified_gmt, post_content_filtered, post_parent, guid, menu_order, post_type, post_mime_type, comment_count)

Dando forma

Bom, digitamos manualmente INSERT INTO e VALUES, no começo da primeira linha e ao final, respectivamente.

Na linha de baixo, vamos utilizar uma coisinha legal:

:2s/\([^,]*\)[,]?/'%s', /g

O que acaba na seguinte transformação linha 2:

'%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s',

Basta ajustar os detalhes, parênteses e vírgulas a mais! (Poderia ser feito um grupo na vírgula, pra se caso ela existir, colocar, e não por, caso contrário. Mas eu achei muita frescura) E agora o toque final:

:3s/\([^,()]*\)[,]?/addslashes($_POST['\1']), /g

O que retorna:

addslashes($_POST['(ID']), addslashes($_POST['post_author']), addslashes($_POST['post_date']), addslashes($_POST['post_date_gmt']), addslashes($_POST['post_content']), addslashes($_POST['post_title']), addslashes($_POST['post_category']), addslashes($_POST['post_excerpt']), addslashes($_POST['post_status']), addslashes($_POST['comment_status']), addslashes($_POST['ping_status']), addslashes($_POST['post_password']), addslashes($_POST['post_name']), addslashes($_POST['to_ping']), addslashes($_POST['pinged']), addslashes($_POST['post_modified']), addslashes($_POST['post_modified_gmt']), addslashes($_POST['post_content_filtered']), addslashes($_POST['post_parent']), addslashes($_POST['guid']), addslashes($_POST['menu_order']), addslashes($_POST['post_type']), addslashes($_POST['post_mime_type']), addslashes($_POST['comment_count)']),

E, para concluir tudo, colocamos dentro de um sprintf, tudo termina assim:

$insertSQL = sprintf("INSERT INTO (ID, post_author, post_date, post_date_gmt, post_content, post_title, post_category, post_excerpt, post_status, comment_status, ping_status, post_password, post_name, to_ping, pinged, post_modified, post_modified_gmt, post_content_filtered, post_parent, guid, menu_order, post_type, post_mime_type, comment_count) VALUES (
'%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s'
)",addslashes($_POST['ID']), addslashes($_POST['post_author']), addslashes($_POST['post_date']), addslashes($_POST['post_date_gmt']), addslashes($_POST['post_content']), addslashes($_POST['post_title']), addslashes($_POST['post_category']), addslashes($_POST['post_excerpt']), addslashes($_POST['post_status']), addslashes($_POST['comment_status']), addslashes($_POST['ping_status']), addslashes($_POST['post_password']), addslashes($_POST['post_name']), addslashes($_POST['to_ping']), addslashes($_POST['pinged']), addslashes($_POST['post_modified']), addslashes($_POST['post_modified_gmt']), addslashes($_POST['post_content_filtered']), addslashes($_POST['post_parent']), addslashes($_POST['guid']), addslashes($_POST['menu_order']), addslashes($_POST['post_type']), addslashes($_POST['post_mime_type']), addslashes($_POST['comment_count']));

Ah, vamos, não foi tão difícil nem demorado! Garanto que você perderia mais tempo tendo que fazer isso manualmente!

Copiando do phpMyAdmin:

Bom, para aqueles que trabalham com o phpMyAdmin, basta ir na tabela deseja e, da aba Estrutura, copiar a tabela para o GVim, vai ficar algo mais ou menos assim:

ID  	bigint(20)  	 	UNSIGNED  	Não  	 	auto_increment  	  Navegador distingue valores   	  Alterar   	  Eliminar   	  Primária   	  Único   	  Índice   	 Texto completo
	post_author 	bigint(20) 			Não 	0 		Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	post_date 	datetime 			Não 	0000-00-00 00:00:00 		Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	post_date_gmt 	datetime 			Não 	0000-00-00 00:00:00 		Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	post_content 	longtext 	utf8_general_ci 		Não 			Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	post_title 	text 	utf8_general_ci 		Não 			Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	post_category 	int(4) 			Não 	0 		Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	post_excerpt 	text 	utf8_general_ci 		Não 			Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	post_status 	varchar(20) 	utf8_general_ci 		Não 	publish 		Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	comment_status 	varchar(20) 	utf8_general_ci 		Não 	open 		Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	ping_status 	varchar(20) 	utf8_general_ci 		Não 	open 		Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	post_password 	varchar(20) 	utf8_general_ci 		Não 			Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	post_name 	varchar(200) 	utf8_general_ci 		Não 			Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	to_ping 	text 	utf8_general_ci 		Não 			Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	pinged 	text 	utf8_general_ci 		Não 			Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	post_modified 	datetime 			Não 	0000-00-00 00:00:00 		Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	post_modified_gmt 	datetime 			Não 	0000-00-00 00:00:00 		Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	post_content_filtered 	text 	utf8_general_ci 		Não 			Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	post_parent 	bigint(20) 			Não 	0 		Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	guid 	varchar(255) 	utf8_general_ci 		Não 			Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	menu_order 	int(11) 			Não 	0 		Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	post_type 	varchar(20) 	utf8_general_ci 		Não 	post 		Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	post_mime_type 	varchar(100) 	utf8_general_ci 		Não 			Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	comment_count 	bigint(20) 			Não 	0 		Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo

Vamos remover o que não nos é necessário e pegar somente a primeira coluna dessa tabela separada por tabs, digitando no GVim:

:%s/\s*\([^ \t]*\).*/\1/g

Bom, conseguimos o que queríamos. Uma coluna em cada linha. Agora é só concluir como descrito acima, onde os dados provém do terminal. o/

Conclusão

Idéias, sugestões, receitas de bolos e muito mais, vocês podem me mandar por e-mail ou comentar abaixo!
E lembrem-se: mais dicas de coisas que podem ser feitas no GVim estão por vir!