Clique abaixo para nos ajudar
Conectar-se

Esqueci minha senha

Estamos no Facebook
Buscar
 
 

Resultados por:
 


Rechercher Busca avançada

Quem está conectado
16 usuários online :: Nenhum usuário registrado, Nenhum Invisível e 16 Visitantes :: 1 Motor de busca

Nenhum

[ Ver toda a lista ]


O recorde de usuários online foi de 468 em 1/3/2012, 10:43
TRY BEGIN E FLOCK()

17/4/2017, 10:32 por AJC

Pessoal estou tendo alguns problemas de gravação em rede, estou usando
try begin, mas vi algo na …

Comentários: 0

Exportar Dados Campo Memo Tabela DBF

10/4/2017, 10:28 por fcampos

Olá bom dia.

Estou tentando exportar os dados de algumas tabelas em formato dbf pelo foxpro.
O …

Comentários: 2

Função EVL()

8/4/2017, 12:18 por Clebervfp

Bom dia a todos.
Vim compartilhar de uma Função do próprio VFP que me benefício muito.
Função …

Comentários: 0

COMO BLOQUEAR REGISTRO OU TABELA NO VISUAL FOXPRO PARA GRAVAÇÃO EM REDE

3/4/2017, 10:29 por AJC

Pessoal estou tendo um problema que acontece sempre busco na minha tabela de clientes o ultimo …

Comentários: 2

Controlar Scanner Twain

31/3/2017, 17:31 por Kleber R Bento

Estou usando o EZTW32.DLL para criar uma ferramenta que escaneia e gera PDF. Porém com esses …

Comentários: 0

Estatísticas
Temos 7067 usuários registrados
O último usuário registrado atende pelo nome de Preula

Os nossos membros postaram um total de 48 mensagens em 25 assuntos

Introducao ao MySql Linux

Ver o tópico anterior Ver o tópico seguinte Ir em baixo

Tutorial Introducao ao MySql Linux

Mensagem por hugo em 12/1/2010, 16:12


O software

SGBD (Sistema Gerenciador de Banco de Dados)
A definição de um SGBD é basicamente ser um sistema cujo objetivo principal é gerenciar o acesso e a correta manutenção dos dados armazenados em um banco de dados. Quem se lembra do Clipper conseqüentemente lembra do dBase, que foi o primeiro SGBD a ser utilizado em larga escala.


O MySQL

O MySQL foi criado na Suécia e no início deste ano, a MySQL AB, desenvolvedora do MySQL, foi adquirida pela Sun Microsystems por US$ 1 bilhão. Quando ele foi projetado atendia aplicações de pequeno a médio porte (aproximadamente 100 milhões de registros por tabela, tendo como base o tamanho de 100mb por tabela), mas com seu desenvolvimento ele atende muito além disso!

Podemos citar algumas características sobre o MySQL, que são:
-Portabilidade;
-Multithreads (maior integração com máquina com mais de um processador);
-Formas de armazenamento (MyISAM, InnoDB);
-Velocidade (utilização de cache em consultas indexação);
-Segurança (criptografia, conexão limitada);
-Armazenamento de procedimentos;
-Replicação de dados entre servidores MySQL;
-Capacidade (utilizando tabelas InnoDB, onde o armazenamento é feito por 1 ou mais arquivos, é possível armazenar 65.536TB, eu acho que um desses ajuda)

Podemos encontrar utilizações do MySQL com diversos softwares. Para um programador PHP, Java, Ruby etc, o MySQL é altamente recomendado.


Creditos:
vivaolinux.com.br
marcosmiras

Continua...


Última edição por hugo em 12/1/2010, 16:54, editado 3 vez(es)

_________________
"A tristeza é a falta de alegria, mais sem ela eu não poderia entender a alegria do fato de que a felicidade existe!"
Helio Leites - http://www.youtube.com/watch?v=3NUEXX_yOL0
avatar
hugo
Usuário 5 Estrelas
Usuário 5 Estrelas


Voltar ao Topo Ir em baixo

Tutorial A Instalação do MySQL

Mensagem por hugo em 12/1/2010, 16:26

Instalação do MySQL

Você por instalar das seguintes maneiras:

Código:
# apt-get install mysql mysql-server mysql-client

Ou:

Código:
# yum install mysql mysql-server mysql-client

Ou ir ao site www.dev.mysql.com e baixar os fontes e instalar:

Código:
# ./configure
# make && make install

A instalação pode gerar falhas por dependências, por isso leia bem os erros na instalação caso ocorra!

Antes de mais nada, você deve logar como root para usar os comandos abaixo e o MySQL precisa de um grupo e usuário para funcionar.

Faça o download do código-fonte do MySQL em:
http://dev.mysql.com/get/Downloads/MySQL-5.1/mysql-5.1.42-linux-i686-icc-glibc23.tar.gz/from/pick


Agora vamos criar um grupo para o mysql, digite o seguinte comando no prompt:

Código:
# groupadd mysql


Depois vamos criar um usuário:

Código:
# useradd -g mysql mysql


Logo depois vamos instalar ele no diretório /usr/local, para isto digite o seguinte:

Código:
# cd /usr/local


Agora vamos desagrupar e descompactar o arquivo mysql-5.1.42-linux-i686-icc-glibc23.tar.gz

Código:
# tar -zxvf mysql-5.1.42-linux-i686-icc-glibc23.tar.gz


Ele irá criar um diretório chamado mysql-5.1.42-linux-i686-icc-glibc23 na pasta /usr/local/. Vamos agora criar um link simbólico para o MySQL, para isto digite:

Código:
# ln -s /usr/local/mysql-5.1.42-linux-i686-icc-glibc23 mysql


Vamos entrar no diretório do MySQL:

Código:
# cd mysql


Será preciso executar o arquivo mysql_install_db para instalar a base de dados, digite:

Código:
# scripts/mysql_install_db


Pronto, a base de dados do MySQL está instalada, agora temos que dar algumas permissões para o usuário "mysql". Digite o seguinte:

Código:
# chown -R root .
# chown -R mysql data
# chgrp -R mysql .


Para finalizarmos, digite o seguinte:

Código:
# bin/safe_mysqld --user=mysql &
# /usr/local/mysql/support-files/mysql.server start


Agora o MySQL está pronto para ser usado.

Um detalhe, pelo fato de não ter usado compilação, quando você reiniciar o Linux o MySQL não irá funcionar, você deve colocá-lo para startar na inicialização do Linux, então vamos criar um script para isso:

Código:
# cd /
# pico mysql


Dentro do arquivo digite:

Código:
/usr/local/mysql/support-files/mysql_server start


Depois salve o arquivo (Ctrl+x, e depois Y). Agora vamos tornar esse arquivo executável, digite:

Código:
# chmod +x mysql


Depois basta copiar ele para a pasta /bin:

Código:
# cp mysql /bin


Agora toda vez que você digitar "mysql", o MySQL irá abrir. Para finalizarmos, vamos colocar ele na inicialização do sistema, faça o seguinte:

Código:
# pico /etc/rc.d/rc.local


Dentro do arquivo digite o seguinte:

Código:
# Inicio do Mysql
mysql
echo "Iniciando Mysql..."
# Fim do Mysql


Salve o arquivo (Ctrl+x, depois Y) e pronto! Finalmente seu Mysql está prontinho para você usar a hora que quiser.


OBS.:
Pós-instalação

Após a instalação será dado um alerta em seu console para que você defina a senha de root, só que para isso o MySQL deverá estar no ar:

Código:
#/etc/init.d/mysqld start (ou mysql)

Depois de iniciado defina a senha de root:

Código:
# mysqladmin -u root password senha


Creditos:
vivaolinux.com.br
Adriano Santos - adriano@gbi.com.br

Continua....

_________________
"A tristeza é a falta de alegria, mais sem ela eu não poderia entender a alegria do fato de que a felicidade existe!"
Helio Leites - http://www.youtube.com/watch?v=3NUEXX_yOL0
avatar
hugo
Usuário 5 Estrelas
Usuário 5 Estrelas


Voltar ao Topo Ir em baixo

Tutorial Armazenamento, criação e manipulacao

Mensagem por hugo em 12/1/2010, 16:46

Entendendo alguns métodos de funcionamento.

MyISAM
O MyISAM é o mecanismo padrão do MySQL, é o mecanismo que apresenta os melhores resultados. Seu método de armazenamento é muito rápido, sem restrições de uso, que inclui todos os recursos do MySQL exceto o suporte à transações.

Nome: MyISAM
Suporte a índices: SIM
Suporte a transações: NÃO
Tipos de dados não suportados: -
Nível de bloqueio: TABELA


InnoDB
Apesar do MyISAM ser o que apresenta os melhores resultados, é o InnoDB que é recomendado para grandes e complexos bancos de dados, pois permite o uso de transações com propriedades ACID (Atomicidade, Consistência, Isolamento e Durabilidade).

Nome: InnoDB
Suporte a índices: SIM
Suporte a transações: SIM (AICD)
Tipos de dados não suportados: -
Nível de bloqueio: LINHA


MEMORY (HEAP)
O armazenamento das informações do Memory é na memória RAM da máquina que o hospeda. Seu uso é indicado para dados temporários (imagine se acaba a carga do no-break!!!).

Nome: MEMORY
Suporte a índices: NÃO
Suporte a transações: NÃO
Tipos de dados não suportados: BLOB e TEXT
Nível de bloqueio: TABELA


BerkeleyDB
Seu armazenamento é baseado na geração de um HASH que é armazenado com cada registro inserido no banco de dados, funcionando como uma espécie de chave primária de registros.

Nome: BDB
Suporte a índices: SIM
Suporte a transações: SIM
Tipos de dados não suportados: -
Nível de bloqueio: PÁGINA (blocos de 8mb)

Existem ainda o EXAMPLE, ARCHIVE, CSV e BLACKHOLE.


Criando um banco de dados
Depois de tanta história vamos ao que interessa, o primeiro passo é conectarmos ao mysql e criarmos um banco de dados:

# mysql -p
Enter password:

Ao olharmos quais as bases existentes podemos encontrar:

mysql> SHOW DATABASES;
+----------------------------+
| Database |
+----------------------------+
| information_schema |
| mysql |
+----------------------------+

A
base mysql é onde ficam todos os parâmetros do MySQL, inclusive usuários e senhas, já a base information_schema fornece a informação das estruturas dos bancos de dados locais.

Vamos criar um banco novo e atribuir um usuário:

Código:
mysql> CREATE DATABASE minha_base;
mysql> USE minha_base;
mysql> GRANT ALL PRIVILEGES ON base.* TO usuario@'localhost' IDENTIFIED BY 'senha';

Parece simples, mas em três linhas temos que tomar cuidado extremo e já vemos algumas das inúmeras ferramentas do MySQL, veja:

A primeira linha indica criação do novo banco, a segunda ativa a base criada ou desejada e a terceira cria um novo usuário com direitos:
grant - atribui.
all privileges - todos os privilégios (ALTER, CREATE, DELETE, DROP, EVENT, EXECUTE, ...).
on base.* - no banco "base" e em todas as suas tabelas.
to teste@'localhost' - para o usuário "teste" (nesse caso ele já cria automaticamente o usuário) em localhost, aqui você poderia alterar por um ip ou range de rede, caso a conexão possa ocorrer de qualquer local você pode usar o parâmetro '%'.
identified by 'senha' - requer essa determinada senha para realizar conexão.

Veremos mais sobre o grant na página 5.

Vejamos se foi criada:

mysql> SHOW DATABASES;
+----------------------------+
| Database |
+----------------------------+
| information_schema |
| minha_base |
| mysql |
+----------------------------+

Para renomear o banco:

Código:
mysql> RENAME DATABASE minha_base TO joaozinho;
mysql> SHOW DATABASES;

+------------------------+
| Database |
+------------------------+
| information_schema |
| joaozinho |
| mysql |
+------------------------+

Para excluir:

Código:
mysql> DROP DATABASE joaozinho;
mysql> SHOW DATABASES;

+------------------------+
| Database |
+------------------------+
| information_schema |
| mysql |
+------------------------+
Vamos criar a base novamente para que possamos trabalhar:

Código:
mysql> CREATE DATABASE minha_base;


Criando tabela e inserindo, atualizando e excluindo dados

Particularmente eu considero a linha de comando do MySQL um pouco chatinha, prefiro uma interface gráfica. Pesquisando encontrei algumas, mas a que mais me agradou foi o MySQL Query Browser, que pode ser baixado no site do MySQL.

Já que criamos nossa base e compreendemos um pouco mais sobre o MySQL, vamos criar algumas tabelas:

Carregue a base:

Código:
mysql> USE minha_base;

Vamos criar uma tabela com os campos NOME, EMAIL, DATA:

Código:
mysql> create table tabela1 (nome VARCHAR(20), email VARCHAR(20), data DATE);

Vejamos se a mesma foi criada:

Código:
mysql> SHOW TABLES;
+-------------------------------+
| Tables_in_minha_base |
+-------------------------------+
| tabela1 |
+-------------------------------+
E vejamos os campos que ela possui:

Código:
mysql> DESC tabela1;
+-------+----------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-------+----------------+------+-----+---------+-------+
| nome | varchar(20) | YES | | NULL | |
| email | varchar(20) | YES | | NULL | |
| data | date | YES | | NULL | |
+-------+----------------+------+-----+---------+-------+
E vamos inserir dados nessa tabela:

Código:
mysql> INSERT INTO tabela1 VALUES ('Marcos Miras' , 'marcosmiras@atmsystem.com.br' , '2008-09-19');
mysql> SELECT * FROM tabela1;
+-----------------+-------------------------------------+---------------+
| nome | email | data |
+-----------------+-------------------------------------+----------------+
| Marcos Miras | marcosmiras@atmsyste | 2008-09-19 |
+-----------------+-------------------------------------+----------------+

Vamos atualizar esse valor do campo "email":

Código:
mysql> UPDATE tabela1 SET email='marcos@atmsystem.com';
mysql> SELECT * FROM tabela1;
+-----------------+------------------------------------+----------------+
| nome | email | data |
+-----------------+------------------------------------+----------------+
| Marcos Miras | marcos@atmsystem.com | 2008-09-19 |
+-----------------+------------------------------------+----------------+

Excluindo a entrada de registro:

Código:
mysql> DELETE FROM tabela1;
mysql> SELECT * FROM tabela1;
Empty set (0.00 sec)

Porém, percebe-se que o comando insert atualiza o campo determinado de todos os registros da tabela e o comando "delete" exclui todos os dados da tabela, para resolver esse problema conheceremos a cláusula "where". Para testar vamos fazer várias inserções na tabela:

Código:
mysql> INSERT INTO tabela1 VALUES ('Joao Silva' , 'joao@dominio' , '2008-09-19');
mysql> INSERT INTO tabela1 VALUES ('Jose Pereira' , 'ze@dominio' , '2008-09-19');
mysql> INSERT INTO tabela1 VALUES ('Maria' , 'maria@dominio' , '2008-09-19');
mysql> INSERT INTO tabela1 VALUES ('Pedro' , 'pedro@dominio' , '2008-09-19');
mysql> SELECT * FROM tabela1;
+---------------+----------------------+----------------+
| nome | email | data |
+---------------+----------------------+----------------+
| Joao Silva | joao@dominio | 2008-09-19 |
| Jose Pereira | ze@dominio | 2008-09-19 |
| Maria | maria@dominio | 2008-09-19 |
| Pedro | pedro@dominio | 2008-09-19 |
+---------------+----------------------+----------------+

Utilizando o "where" vamos selecionar os registros da tabela1 que contenham "Pedro":

Código:
mysql> SELECT * FROM tabela1 WHERE nome="Pedro";
+--------+----------------------+----------------+
| nome | email | data |
+--------+----------------------+----------------+
| Pedro | pedro@dominio | 2008-09-19 |
+--------+----------------------+----------------+

Sendo assim podemos excluir e atualizar os dados que queremos:

Código:
mysql> UPDATE tabela1 SET email='pd@dominio2' where nome="Pedro";
mysql> UPDATE tabela1 SET nome='Maria Souza' where nome='Maria';
mysql> DELETE FROM tabela1 where nome='Joao Silva';

Verifique suas alterações com o "select".

O "delete" exclui os dados da tabela, agora se você deseja excluir a tabela você pode usar o "drop", assim como na exclusão do base (vista na página anterior).

Código:
mysql> DROP TABLE tabela1;


Manipulando a tabela

Bom, aprendemos a criar uma base, criar uma tabela e manipular dados dentro dessa estrutura, agora veremos algumas funções que podemos utilizar em nossa tabela.

Adicionando, renomeando e excluindo uma coluna na tabela
Bom pessoal, pode acontecer que depois de você criar toda sua estrutura haja uma falha de raciocínio lógico e acabe esquecendo de alguma coluna, claro que é recomendável que crie uma estrutura num papel e depois execute-a para que tudo possa estar certinho, mas caso você não alertou para esse fato, pode resolver esse problema utilizando o "alter table".

Código:
mysql> ALTER TABLE tabela1 ADD COLUMN sexo varchar(1) AFTER email;

Ou seja, estou dizendo para que ele modifique a tabela chamada "tabela1" adicionando o campo "sexo", com tipo de dado 1 caractere de texto, depois da coluna "email".

Podemos também atualizar um campo já existente de uma tabela:

Código:
mysql> ALTER TABLE tabela1 CHANGE email mail VARCHAR(40);

Veja como a estrutura de nossa tabela mudou:

Código:
mysql> DESC tabela1;
+--------+----------------+-------+-----+---------+--------+
| Field | Type | Null | Key | Default | Extra |
+--------+----------------+-------+-----+---------+--------+
| nome | varchar(20) | YES | | NULL | |
| mail | varchar(40) | YES | | NULL | |
| sexo | varchar(1) | YES | | NULL | |
| data | date | YES | | NULL | |
+--------+----------------+------+------+---------+--------+

Para excluirmos uma coluna podemos utilizar o seguinte:

Código:
mysql> ALTER TABLE tabela1 DROP sexo;


Bloqueando uma tabela
Em alguns casos é necessário que haja um bloqueio da tabela para determinada tarefa, isso ocorre em situações de transações, exportação de backup, alterações em grande volume de dados e assim adiante:

Código:
mysql> LOCK TABLES tabela1 READ;

O comando acima faz com que só haja a leitura dessa tabela, entre as funções podemos mesclar o lock tables com:
READ - Como vimos, só deixa fazer consulta (ler).
READ LOCAL - Permite que inserções não-conflitantes sejam realizadas (não funciona em tabelas InnoDB).
WRITE - Permite que a thread que solicitou o bloqueio possa escrever e atualizar registros e as demais threads possam somente ler.
LOW_PRIORITY WRITE - Bloqueia a tabela para inserção e alteração, permite que outros processos bloqueiem essa tabela para leitura. A thread que solicitar o bloqueio de escrita deverá esperar a thread que bloqueou a leitura acabe seu processamento.


Desbloqueando uma tabela
mysql> UNLOCK TABLES;
mysql> FLUSH TABLES;

Requer o flush para que todas as informações sobre índices sejam gravados em disco.

Creditos:
marcosmiras
www.vivaolinux.com.br

Continua...

_________________
"A tristeza é a falta de alegria, mais sem ela eu não poderia entender a alegria do fato de que a felicidade existe!"
Helio Leites - http://www.youtube.com/watch?v=3NUEXX_yOL0
avatar
hugo
Usuário 5 Estrelas
Usuário 5 Estrelas


Voltar ao Topo Ir em baixo

Tutorial Permissoes

Mensagem por hugo em 12/1/2010, 16:57

Permissões
Chegamos a um ponto que eu estava ansioso para escrever, como disse no início vejo aqui no fórum diversas pessoas com esse problema. As permissões no MySQL são tão simples quanto no Linux.

Essas permissões vão definir em qual base e tabela é definida a permissão, qual o usuário, onde ele está e qual a senha dele. Para tal procedimento usaremos o grant.


Criando um usuário no MySQL
O comando "create user" é a forma mais rápida de criar um usuário e definir sua senha, porém não existe uma tratativa sobre os direitos desse novo usuário:

Código:
mysql> CREATE USER fulano IDENTIFIED BY 'senha';

Saia do prompt mysql e entre com o usuário novo:

Código:
# mysql -ufulano -p
mysql>

Você pode também excluir o usuário:

Código:
mysql> DROP USER fulano;


Direitos de acesso no MySQL
O grant possui as seguintes opções de acesso:
ALL/ALL PRIVILEGES - Simboliza todos os privilégios abaixo.
ALTER - Permite alterar a estrutura de tabelas.
ALTER ROUTINE - Permite alterar e excluir stored procedures / functions.
CREATE - Permite criar banco de dados e tabelas.
CREATE ROUTINE - Permite criar stored procedures / functions.
CREATE TEMPORARY TABLES - Permite a criação de tabelas temporárias em expressões SQL que utilizam esse recurso.
CREATE USER - Permite criar e gerenciar usuários.
CREATE VIEW - Permite criar visões.
DELETE - Permite excluir informações.
DROP - Permite excluir estruturas (bases e tabelas).
EVENT - Permite criar event schedulers.
EXECUTE - Permite executar stored procedures.
FILE - Permite ler e escrever arquivos no sistema.
GRANT - Permite cadastrar seus privilégios para outros usuários.
INDEX - Permite o gerenciamento de índices.
INSERT - Permite inserir informações em tabelas.
LOCK TABLES - Permite bloquear tabelas.
PROCESS - Permite visualizar e finalizar processos do MySQL.
RELOAD - Permite recarregar bancos de dados.
REPLICATION CLIENT - Permite solicitar replicação.
REPLICATION SLAVE - Permite replicar suas informações.
SELECT - Permite consultas.
SHOW DATABASES - Permite visualizar todas as estruturas dos bancos existentes
SHOW VIEW - Permite visualizar os códigos de criação de visões.
SHUTDOWN - Permite desligar o servidor MySQL.
SUPER - Permite configurar os dados do servidor MASTER (em caso de replicação).
TRIGGER - Permite criar e gerenciar triggers.
UPDATE - Permite alterar informações em tabelas.
USAGE - Permite utilizar comandos básicos.

A sintaxe do grant é a seguinte:

grant <privilégios> on <banco>.<tabela> to '<usuario>'@'<dominio>' identified by '<senha>'

Agora criaremos um usuário com os mesmos privilégios do root:

Código:
mysql> CREATE USER dba;
mysql> GRANT ALL PRIVILEGES ON *.* TO dba@'localhost' IDENTIFIED BY 'passworddba';

E um usuário para somente leitura:

Código:
mysql> CREATE USER estagiario;
mysql> GRANT SELECT ON minha_base.* TO 'estagiario'@'%' IDENTIFIED BY 'estag';

O parâmetro "%" representa qualquer domínio, ou seja, o usuário estagiário para consultar todas as tabelas de "minha_base" mediante a senha "estag". Caso você deseje consultar os privilégios do usuário poderemos utilizar o seguinte comando (repare que no campo de senha é gerado um hash, como explicado anteriormente):

Código:
mysql> SHOW GRANTS FOR 'estagiario'@'%';
GRANT SELECT ON `minha_base`.* TO 'estagiario'@'%'

Sempre que mudar/setar algum tipo de permissão no MySQL, o comando de atualiza a lista de privilégios faz-se necessário:

Código:
mysql> FLUSH PRIVILEGES;

Caso o estagiário esteja abusando com os "selects" da vida, podemos retirar os direitos de acesso com o comando REVOKE, veja:

Código:
mysql> REVOKE SELECT ON minha_base.* FROM 'estagiario'@'%';

Ainda se for necessário, podemos excluir ou alterar a senha desse usuário:

Código:
mysql> SET PASSWORD FOR 'estagiario' = PASSWORD('nova_senha');
mysql> DROP USER 'estagiario';



Segurança e configuração

Segurança no MySQL

Bom pessoal, agora que já conhecemos o MySQL um pouco mais, temos que saber duas coisas bem importantes nesse mundinho de informática, a performance e a segurança, essas duas palavras podem ocasionar uma promoção ou uma demissão, então seguiremos atentos as duas!

Primeiro queria falar brevemente sobre segurança, existe um detalhe no MySQL que me incomoda e que todos nós conhecemos, o /root/.bash_history. Lá fica armazenado todo o histórico de comandos do root, mas existe também o /root/.mysql_history, Porém existem uma diferença entre ambos.

Quando criamos um novo usuário no Linux, percebemos que no momento de informar a senha ele não exibe no bash, logo, não existe inserção desse determinado dado no arquivo ".bash_history". No MySQL é diferente, quando criamos um usuário e informamos a senha, ele exibe no bash, sendo assim, existe inserção no arquivo ".mysql_history".

Executando o tail verifiquemos o conteúdo do .mysql_history:

Código:
# tail -f /root/.mysql_history
CREATE USER estagiario;
GRANT SELECT minha_base.* TO 'estagiario'@'%' identified by 'estag';
SHOW GRANTS FOR 'estagiario'@'%';
REVOKE SELECT ON minha_base.* FROM 'estagiario'@'%';
SET PASSWORD FOR 'estagiario' = PASSWORD('nova_senha');
DROP USER 'estagiario';

Preste atenção na penúltima linha. Puxa, interessante não!? Particularmente sempre agendo uma tarefa no cron para excluir o arquivo ".mysql_history". Lembre-se também de proteger em seu firewall a porta 3306 (porta de comunicação do MySQL), liberando somente o necessário!


Configuração do MySQL
Bem, essa parte não é tão complicada como parece, o MySQL vem com alguns arquivos de configuração:
my-small.cnf - Servidores com 64 a 128 megas de memória RAM dedicadas ao MySQL.
my-medium.cnf - Servidores com 128 a 256 megas de memória RAM dedicadas ao MySQL.
my-medium.cnf - Servidores com 256 a 512 megas de memória RAM dedicadas ao MySQL.
my-large.cnf - Servidores com 512 megas a 1 Gb de memória RAM dedicadas ao MySQL.
my-huge.cnf - Servidores com mais de 1 Gb de memória RAM dedicada ao MySQL.


Contudo temos estas configuracoes que se seguem:

Os comentários seguem no próprio .cnf, mas vale ressaltar que o pulo do gato são as variáveis:
key_buffer, table_cache e max_connections.

Código:
[client]
port      = 3306
socket      = /var/run/mysqld/mysqld.sock

[safe_mysqld]
err-log      = /var/log/mysql/mysql.err

[mysqld]
server-id=10
log-bin=/var/log/mysql/mysql-bin.log
binlog-do-db=pop
binlog-ignore-db=mailstats,mysql,pop.bak,radius,radius.bak,test

user      = mysql
pid-file  = /var/run/mysqld/mysqld.pid
socket      = /var/run/mysqld/mysqld.sock
port      = 3306
log      = /var/log/mysql.log
basedir      = /usr
datadir      = /var/lib/mysql
tmpdir      = /tmp
language  = /usr/share/mysql/english
skip-locking

# key-buffer define quanto de memória será armazenado para
# gravar dados de consultas do MySQL. Quanto maior a quantidade
# de memória disponível, melhor será o desempenho do servidor
set-variable    = key_buffer=312M

set-variable    = max_allowed_packet=1M

# table_cache é muito importante, este número deve ser o dobro
# do número definido pela variável max_connections
set-variable    = table_cache=20000

set-variable    = sort_buffer=1M
set-variable    = record_buffer=1M
set-variable    = myisam_sort_buffer_size=64M
set-variable    = thread_cache=8
set-variable    = thread_concurrency=8

# max_connections vai definir quantos sub-processos e
# consequentemente quantas conexões seu MySQL suportará
# simultaneamente. Por incrível que pareça, quanto maior este
# número, menor será o load do seu server. Tente restringir este
# para um número baixo e você verá que loucura está fazendo
set-variable    = max_connections=10000

set-variable    = net_write_timeout=30
set-variable    = connect_timeout=2
set-variable    = wait_timeout=30

# Read the manual if you want to enable InnoDB!
skip-innodb

[mysqldump]
quick
set-variable  = max_allowed_packet=1M

[mysql]

[isamchk]
set-variable  = key_buffer=64M # era 16M

download do .cnfFACA O DOWNLOAD AQUI DO .CNF



Encontre mais sobre o MySql em:

=>> http://www.vivaolinux.com.br/comunidade/MySQL

http://dev.mysql.com/
http://www.mysqlbrasil.com.br/
http://br2.php.net/manual/pt_BR/book.mysql.php
http://planet.mysql.com/
http://forums.mysql.com/


Espero ter ajudado!

_________________
"A tristeza é a falta de alegria, mais sem ela eu não poderia entender a alegria do fato de que a felicidade existe!"
Helio Leites - http://www.youtube.com/watch?v=3NUEXX_yOL0
avatar
hugo
Usuário 5 Estrelas
Usuário 5 Estrelas


Voltar ao Topo Ir em baixo

Ver o tópico anterior Ver o tópico seguinte Voltar ao Topo


 
Permissão deste fórum:
Você não pode responder aos tópicos neste fórum