Este será um how-to (guia) básico para demonstrar o uso do banco de dados servidor MySQL em Prisma.
Pré-requisitos:
- Prisma-1.0.99 ou superior.
- Servidor Xampp instalado e MySQL configurado.
Links:
Instalando Xampp no Windows:
https://linguagemprisma.br4.biz/blog/instalando-xampp-no-windows/
Configurando MySQL no Win.:
https://linguagemprisma.br4.biz/blog/configurando-mysql-xampp-em-windows/
Instalando Xampp no Linux:
https://linguagemprisma.br4.biz/blog/instalando-servidor-xampp/
Configurando Acesso Remoto no Linux: clique aqui
Sobre o Banco de dados:
Para você que é novato no assunto e está se perguntando: o que é um banco de dados (o que é MySQL?)?
Você deveria se perguntar: para que serve?
(Pule esta parte se já souber)
BD (banco de dados) é um arquivo que armazena dados. Quando dizemos MySQL, SQlite3 ou Postgre etc. Estamos nos referindo ao programa ou biblioteca que tem as funções necessárias para criar e manipular o arquivo do banco de dados.
Um banco de dados, por exemplo, pode armazenar clientes, produtos, telefones, etc. Muito útil em programas de lojas, Mercados, etc.
Se você ainda quer mais detalhes sobre BD, dê uma breve volta pelo Gloogle.
Começando a programar:
1 – Obtendo a versão:
Crie um arquivo prisma chamado versao.prisma em uma pasta específica para este tutorial. (Dê preferência aos editores Geany ou Prismacod);
|
1 2 3 4 5 |
local mysql = inclua'mysql' imprima('informacao cliente mysql:', mysql.obt_cliente_info() ); imprima('versao desta lib:', mysql._versao ); |
Saída:
informacao cliente mysql: 5.5.54
versao desta lib: mysql para Prisma mysql-0.1
|
1 |
local mysql = inclua'mysql' |
Nesta linha a biblioteca mysql Prisma é importada, com isso podemos usar suas funções.
|
1 |
mysql.obt_cliente_info() |
Bem, a função imprima vocês já conhecem, então vamos para essa acima. Ela retorna uma string com o número da versão do cliente MySQL, não é a versão da biblioteca Prisma!
|
1 |
mysql._versao |
Acima temos uma variável reservada string com a descrição da versão da lib Prisma.
2 – Conexão com o servidor MySQL e abertura do banco de dados:
Salve como criabd.prisma
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
//exemplo de conexao e abertura de banco de dados: inclua'mysql' funcao principal() local host = 'localhost'; local user = 'root'; local senha = 'senha-do-servidor';//coloque sua senha do servidor mysql aqui entre aspas. local sock = '/opt/lampp/var/mysql/mysql.sock'; //arquivo socket unix. local conexao, err = mysql.conecte(host,user,senha,nulo,nulo,sock); se err entao//se houver erro imprima('Erro no mysql:', err);//imprima o erro conexao:feche();//libera a conexao sis.saia(1);//retorna 1 e deixa a funcao principal finalizando o programa. senao local err = conexao:exec("CREATE DATABASE testedb");//note o uso dos dois pontos para método exec se err entao imprima("Erro na execucao:", err, 'Enter para sair'); leia(); sis.saia(1); senao imprima("Banco de dados criado com sucesso no servidor MySql"); fim fim conexao:feche();//fecha a conexao. retorne 0;//retorno ao sistema operacional fim |
|
1 |
inclua'mysql' |
Incluindo a biblioteca mysql.
|
1 |
funcao principal() |
Prisma 1.0.99 traz o conceito de função principal, a função com este nome será chamada automaticamente pelo interpretador, é como o main() do C. Lembre-se de fechar no final com o respectivo ‘fim’.
|
1 |
local host = 'localhost'; |
Esta é uma variável com o local (ip) do servidor MySQL.
‘localhost’ indica que o servidor está instalado no mesmo computador que o programa sendo executado. Se o MySQL estiver instalado em outro computador na rede, basta usar o número ip dele entre aspas, ex.: local host = ‘192.168.1.100’;
|
1 2 |
local user = 'root'; local senha = 'senha-do-servidor'; |
Acima temos o usuário e senha do MySQL.
|
1 |
local sock = '/opt/lampp/var/mysql/mysql.sock'; //arquivo socket unix. |
Esta linha acima indica o caminho do arquivo socket unix, não é necessário no Windows, pode deixar como nulo. Caso você tenha instalado o Servidor que não seja o Xampp, procure na documentação o local do arquivo na sua instalação.
|
1 |
local conexao, err = mysql.conecte(host,user,senha,nulo,nulo,sock); |
Esta é a função de conexão com o MySQL,
|
1 |
conexao, err = mysql.conecte(host,user,senha,Bd,porta,sock,flags); |
Parâmetros:
host: o ip do servidor ou ‘localhost’ se estiver na mesma máquina do Xampp servidor MySQL;
user: usuário (‘root’ ou outro criado por você – );
senha: ‘senha’ do MySQL;
Bd: arquivo ‘banco de dados’ ou nulo se você quiser abrir mais tarde. Ex.: ‘teste.db’;
Porta: porta do servidor MySQL. (geralmente é 3306), ou nulo se estiver em ‘localhost’
socket: é o path completo do arquivo socket unix, só é usado quando estiver em localhost, caso contrario deixe nulo.
Ainda temos o último parâmetro que foi omitido no exemplo, este parâmetro é um item de configuração (flag) da conexão.
Usaremos mais a frente quando precisarmos.
Retornos:
conexao: é o objeto MySQL com a conexão e métodos do banco de dados.
err : é o erro retornado. Nulo se não tiver erro.
|
1 |
se err entao//se houver erro |
Nesta linha começa o tratamento de erro, caso o valor da variável err não seja nulo então significa que algum erro aconteceu e sua descrição estará nela em forma de string.
|
1 2 3 |
imprima('Erro no mysql:', err);//imprima o erro conexao:feche();//libera a conexao sis.saia(1);//retorna 1 e deixa a funcao principal finalizando o programa. |
Caso haja erro, esse comando acima é executado:
É impresso o erro na tela, a conexão é fechada, e o programa é fechado com saída 1;
Mas se não houver erro podemos prosseguir com o seguinte comando:
|
1 2 |
senao local err = conexao:exec("CREATE DATABASE testedb");//note o uso dos dois pontos para método exec |
Senão tiver erro, é executado um comando SQL,
CREATE DATABASE testedb;
Significa: crie um banco de dados chamado testedb.
Parâmetros:
String com comando MySQL.
Retorno:
err: string descrevendo o erro, ou nulo se não houver erro.
|
1 2 3 4 |
se err entao imprima("Erro na execucao:", err, 'Enter para sair'); leia(); sis.saia(1); |
Se a execução da cláusula SQL falhar, o erro retornado é impresso na tela e o programa é fechado com saída 1;
Obs.: O comando prisma ‘leia()’ serve para o programa aguardar o usuário pressionar enter, assim dá tempo de ler a mensagem de erro se houver.
Obs. Você deve ter notado que nunca uso a variável erro e sim err, pois erro já existe em prisma e é uma função, lembra?!
|
1 2 3 4 |
senao imprima("Banco de dados criado com sucesso no servidor MySql"); fim fim |
Se o comando SQL for executado com sucesso é impresso a frase de sucesso na tela!
os blocos se,senaose, são todos fechados com o respectivo “fim”;
Obs. Tome cuidado, um fim a mais, ou faltando gera erro.
|
1 2 3 |
conexao:feche();//fecha a conexao. retorne 0;//retorno ao sistema operacional fim |
No final do programa, nunca se esqueça de fechar a conexão aberta com o comando acima.
Ao usar a função principal() em prisma sempre retorne 0 no final, ok!
3 – Criando tabela e inserindo dados:
Salve como inserebd.prisma
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 |
//exemplo de conexao e abertura de banco de dados: inclua'mysql' funcao principal() local host, user, senha, nome_bd = 'localhost','root','senha','testedb';//multipla atribuicao local sock_file = '/opt/lampp/var/mysql/mysql.sock';//caminho do socket no servidor. local conexao, err = mysql.conecte(host,user,senha,nome_bd,nulo,sock_file); tem_erro(conexao,err);//testando se há erro. err = conexao:exec("DROP TABLE IF EXISTS Carros"); //executa uma string de comando sql. //para mais detalhes procure um tutorial mais completo da linguagem sql usada no mysql. tem_erro(conexao,err);//testa novamente se há erro. //criando a tabela: err= conexao:execute("CREATE TABLE Carros(Id INT, Nome TEXT, Preco INT)"); tem_erro(conexao,err); //inserindo dados: err=conexao:exec("INSERT INTO Carros VALUES(1,'Audi',52642)"); tem_erro(conexao,err); err=conexao:exec("INSERT INTO Carros VALUES(2,'Mercedes',57127)"); tem_erro(conexao,err); err=conexao:exec("INSERT INTO Carros VALUES(3,'Skoda',9000)"); tem_erro(conexao,err); err=conexao:exec("INSERT INTO Carros VALUES(4,'Volvo',29000)"); tem_erro(conexao,err); err=conexao:exec("INSERT INTO Carros VALUES(5,'Bentley',350000)"); tem_erro(conexao,err); err=conexao:exec("INSERT INTO Carros VALUES(6,'Citroen',21000)"); tem_erro(conexao,err); err=conexao:exec("INSERT INTO Carros VALUES(7,'Hummer',41400)"); tem_erro(conexao,err); conexao:exec("INSERT INTO Carros VALUES(8,'Volkswagen',21600)"); tem_erro(conexao,err); imprima('Tabela criada e dados inseridos com sucesso!'); conexao:feche();//fecha a conexao. retorne 0;//retorno ao sistema operacional fim //funcao verifica se houve erro e fecha o programa se houver funcao tem_erro(con,err) se err entao con:feche(); imprima(err); sis.saia(0); leia(); fim fim |
Detalhes:
|
1 2 3 4 |
funcao principal() local host, user, senha, nome_bd = 'localhost','root','senha','testedb';//multipla atribuicao local sock_file = '/opt/lampp/var/mysql/mysql.sock';//caminho do socket no servidor. local conexao, err = mysql.conecte(host,user,senha,nome_bd,nulo,sock_file); |
Note a múltipla atribuição de variáveis em prisma! Para cada variável separada por vírgula antes do igual temos um respectivo valor separado por vírgula depois do igual.
Note também que desta vez usamos o quarto parâmetro nome do banco de dados: testedb. Com isso a conexão é criada já com esse banco de dados aberto para manipularmos!
Essa primeira parte você já sabe, passemos adiante.
|
1 |
tem_erro(conexao,err);//testando se há erro. |
A função tem_erro() está desenvolvida no final do programa após a função principal(); isso só é possível quando usamos a função padrão principal(); Veja-a:
|
1 2 3 4 5 6 7 8 |
funcao tem_erro(con,err) se err entao con:feche(); imprima(err); sis.saia(0); leia(); fim fim |
Ela pega a conexão e variável err se encarregando de verificar se há um erro e caso haja fecha a conexao, imprime o erro e sai do programa.
Caso não haja erro ela não faz nada.
|
1 |
err = conexao:exec("DROP TABLE IF EXISTS Carros"); //executa uma string de comando sql. |
Este comando acima executa uma cláusula SQL, que significa:
APAGUE TABELA Carros SE EXISTIR
Parâmetro: String de comandos MySQL;
retorno:
err: string de erro, ou nulo se não houver erros na execução.
|
1 |
tem_erro(conexao,err);//testa novamente se há erro. |
Novamente o tratamento de erros.
|
1 2 3 |
//criando a tabela: err= conexao:execute("CREATE TABLE Carros(Id INT, Nome TEXT, Preco INT)"); tem_erro(conexao,err); |
Acima criamos uma tabela chamada Carros com parâmetros MySQL. O comando significa:
CRIE TABELA Carros com as colunas Id do tipo Inteiro, Coluna Nome do tipo Texto, Preco do tipo Inteiro.
E assim é criada uma tabela no banco de dados testedb com três colunas.
Note que desta vez usamos conexao:execute ao invés de conexao:exec, use a forma que preferir pois as duas fazem a mesma coisa!
O retorno é a variável de erro e é feito o tratamento de erro novamente com a função tem_erro();
Depois de criar o banco de dados, criar a tabela Carros, podemos começar a colocar dados nessa tabela:
|
1 2 |
err=conexao:exec("INSERT INTO Carros VALUES(1,'Audi',52642)"); tem_erro(conexao,err); |
O comando acima é aquele que executa uma cláusula MySQL, lembra?
Parâmetro:
String de comando MySQL que significa:
INSIRA EM Carros VALORES: 1, ‘Audi’, 52642. Na mesma ordem das colunas criadas anteriormente.
Retorno:
err: igual ao anterior, a variável de erro.
Após a execução é feito o tratamento de erro com a função tem_erro();
Bem, os outros comandos são exatamente igual a este de cima, todos inserem dados.
E no final temos:
|
1 2 3 4 |
imprima('Tabela criada e dados inseridos com sucesso!'); conexao:feche();//fecha a conexao. retorne 0;//retorno ao sistema operacional fim |
Imprime a frase de sucesso, pois chegou até aqui sem erros.
fecha a conexão com o comando conexao:feche();
e retorna 0 finalizando o programa!
4 – Lendo todos os dados da tabela
Salve com lendo_bd.prisma
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 |
//lendo a tabela Carros do banco de dados criado no ex_3 inclua'mysql' //incluindo biblioteca mysql funcao principal() local host, user, senha, nome_bd = 'localhost','root','senha','testedb'; local sock = '/opt/lampp/var/mysql/mysql.sock'; local con, err = mysql.conecte(host, user, senha, nome_bd,nulo,sock); tem_erro(con,err); //con recebe os metodos mysql, ao inves de usar msql.exec(con, 'str'); use: err = con->exec("SELECT * FROM Carros");//se preferir use -> para acessar os metodos ao inves de : tem_erro(con,err); local resultado, err = con->obt_resultado();//pegando o resultado executado acima. tem_erro(con,err); //se preferir use num_campos = msql.num_campos(resultado);//dá na mesma, ou siga o modelo objeto: local num_campos = resultado->num_campos();//pegando o numero de campos na tabela Carros. local lin; imprima('-------------------\nseq. Carro preco\n'); enquanto 1 inicio //pegando cada linha a partir do resultado. lin = resultado->obt_linha();//lin é uma tabela prisma contendo os campos da linha lida se lin entao //se linha nao for nulo. para i=1, num_campos inicio imprimaf("%s ", lin[i]) fim; poe'';//para imprimir uma linha em branco no terminal. senao quebre; //quebra o laco enquanto... fim fim//fim enquanto resultado->feche();//liberando o retorno de leitura mysql. con->feche(); //liberando a conexao mysql. retorne 0; fim //fim funcao principal(); //funcao para saida de erro caso houver. funcao tem_erro(con,err) se err entao con->feche(); imprima(err); leia(); sis.saia(1); fim fim |
Detalhes:
|
1 2 |
inclua'mysql' //incluindo biblioteca mysql funcao principal() |
O trecho acima inclua a biblioteca mysql Prisma e inicia a função principal();
|
1 2 3 4 5 |
local host, user, senha, nome_bd = 'localhost','root','senha','testedb'; local sock = '/opt/lampp/var/mysql/mysql.sock'; local con, err = mysql.conecte(host, user, senha, nome_bd,nulo,sock); tem_erro(con,err); |
Nos comandos acima iniciamos a conexão com o servidor MySQL e tratamos do erro com a função tem_erro() igual ao exemplo anterior. Como já vimos esse código antes, não entrarei em detalhes.
|
1 2 |
err = con->exec("SELECT * FROM Carros");//se preferir use -> para acessar os metodos ao inves de : tem_erro(con,err); |
Executamos acima o comando MySQL ‘SELECT * FROM Carros’ que significa:
SELECIONE TODAS AS COLUNAS (*) da tabela Carros.
Note que ao invés dos dois-pontos eu usei “->” para acessar o método exec. Isso é possível na versão Prisma-1.0.99 ou superior. Você escolhe, se preferir use ‘:’ ou ‘->’ para acessar métodos de tabelas.
Parâmetro: string de comando MySQL
retorno: string de erro, ou nulo se não houver erro.
Após a execução é feito o tratamento de erro com a função tem_erro();
Dicas:
Se você quisesse obter apenas uma linha específica adicione WHERE col = valor no fim do comando MySQL, ex.:
|
1 |
err = con->exec("SELECT * FROM Carros WHERE Id = 3"); |
No caso acima, teríamos apenas a linha 3 selecionada.
|
1 |
err = con->exec("SELECT * FROM Carros WHERE Nome = 'Audi'"); |
Acima, seriam selecionadas todas as colunas onde Nome for igual a Audi.
|
1 |
err = con->exec("SELECT * FROM Carros WHERE Id > 2 AND Id < 5"); |
Já aqui teriamos as linhas onde Id for maior que 2 e menor que 5, ou seja, linhas 3 e 4;
|
1 2 |
local resultado, err = con->obt_resultado();//pegando o resultado executado acima. tem_erro(con,err); |
A primeira função acima pega o resultado obtido da execução da cláusula MySQL.
Parâmetros: vazio.
retornos:
resultado: objeto que contém o resultado da execução MySQL.
err: string de erro, ou nulo se não houver erro.
|
1 |
local num_campos = resultado->num_campos();//pegando o numero de campos na tabela Carros. |
Acima temos uma função útil para sabermos automaticamente o número de campos da tabela, ou seja, quantas colunas ela tem.
|
1 2 3 |
local lin; imprima('-------------------\nseq. Carro preco\n'); enquanto 1 inicio //pegando cada linha a partir do resultado. |
Criamos a variavel lin (linha), imprimimos os nomes das colunas.
E iniciamos o laço de repetição enquanto que irá percorrer e ler cada linha de dado da tabela MySQL.
|
1 |
lin = resultado->obt_linha();//lin é uma tabela prisma contendo os campos da linha lida |
Lendo a linha da tabela, cada vez que essa função (resultado->obt_linha();) é repetida ela percorre uma linha da tabela do banco de dados, retornando nulo após chegar ao fim.
Obs. Ela percorre todas as linhas obtidas pelo comando SELECT, então se você selecionar apenas uma linha com o SELECT só será possível ler uma linha.
Como selecionamos todas as linhas da tabela, teremos vários resultados.
Parâmetros: vazio.
Retorno:
lin: tabela contendo informações do resultado lido no comando exec();
Essa tabela contêm os valores, igual ao número de colunas:
lin[1] = valor_da_coluna1,
lin[2] = valor_da_coluna2,
lin[3] = valor_da_coluna3.
De cada linha lida, é claro!
Obs. Se tivéssemos criado uma tabela com 4 colunas teríamos lin[4]!
|
1 2 3 |
se lin entao //se linha nao for nulo. para i=1, num_campos inicio imprimaf("%s ", lin[i]) fim; poe'';//para imprimir uma linha em branco no terminal. |
se linha for válida (diferente de nulo ou falso) podemos usar seus valores, imprimindo-os todos com o comando para:
para i que é 1 até o número de colunas, imprima as linhas. fim
o poe” é para pular uma linha na tela do terminal ou cmd.
|
1 2 3 4 |
senao quebre; //quebra o laco enquanto... fim fim//fim enquanto |
Caso o retorno de lin seja nulo (não existe mais linhas a serem lidas), o laço de repetição enquanto é interrompido com o comando quebre;
Saindo do laço enquanto:
|
1 2 3 4 |
resultado->feche();//liberando o retorno de leitura mysql. con->feche(); //liberando a conexao mysql. retorne 0; fim //fim funcao principal(); |
Fechamos o objeto resultado com a função ->feche();
Fechamos o objeto de conexão con;
retornamos 0 e finalizamos a função principal() com seu respectivo fim!
5 – Lendo o número do último id inserido
Salve como ultimo_id.prisma
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 |
//pegando o ultimo id inserido: local sql = inclua'mysql'; funcao tem_erro(con,err,str) se err entao sql.feche(con); erro("Erro no MySql: " .. err); senao imprima(str); fim fim funcao principal() local host = 'localhost'; local user = 'usuario'; local senha = 'senha'; //coloque senha do servidor aqui. local bd = 'testedb'; //nome do banco de dados já criado local sock = '/opt/lampp/var/mysql/mysql.sock'; local con, err = sql.conecte(host, user, senha, bd,nulo,sock); tem_erro(con,err, 'conexao realizada'); err = con:exec("DROP TABLE IF EXISTS Filosofos"); tem_erro(con,err,''); sql_cmd = "CREATE TABLE Filosofos(Id INT PRIMARY KEY AUTO_INCREMENT, Name TEXT)"; err = con:exec(sql_cmd); tem_erro(con,err,'tabela Filosofos criada'); err = con:exec("INSERT INTO Filosofos(Name) VALUES('Socrates')"); tem_erro(con,err,'dado inserido'); err = con:exec("INSERT INTO Filosofos(Name) VALUES('Platao')"); tem_erro(con,err,'dado inserido'); err = con:exec("INSERT INTO Filosofos(Name) VALUES('Aristoteles')"); tem_erro(con,err,'dado inserido'); imprimaf("O ultimo id inserido é: %d\n", con:ultimo_id() ); con:feche(); retorne 0; fim |
Detalhes:
Atenção vou pular comandos já explicados anteriormente, vamos direto ao que interessa.
|
1 2 |
err = con:exec("DROP TABLE IF EXISTS Filosofos"); tem_erro(con,err,''); |
Executando um comando MySQL e tratando do erro. Lembre-se que esse comando acima apaga a tabela se ela já existir;
|
1 2 |
sql_cmd = "CREATE TABLE Filosofos(Id INT PRIMARY KEY AUTO_INCREMENT, Name TEXT)"; err = con:exec(sql_cmd); |
Criamos a variável que contém a string de comandos MySQL, e depois a executamos com o con:exec();
Veja que criamos a tabela com a coluna Id int chave primária de auto incremento, é necessário este comando MySQL para pegarmos o valor do último Id inserido.
O comando SQL acima significa:
CRIE TABELA Filosofos com: coluna Id do tipo Inteiro Chave primária de auto incremento, coluna Name do tipo Texto.
Após isso é feito o tratamento de erro com a função tem_erro() que agora possui uma novidade: o terceiro parâmetro como mensagem de sucesso.
|
1 2 |
err = con:exec("INSERT INTO Filosofos(Name) VALUES('Socrates')"); tem_erro(con,err,'dado inserido'); |
Acima inserimos os dados na tabela Filosofos, veja que escolhemos as colunas deixando Id de fora pois ela é uma chave de auto incremento (adiciona 1 a cada inserção);
Escolhemos que coluna inserir através do uso de parênteses.
INSIRA EM Filosofos (na coluna Name) VALORES(‘Socrates’);
Se houvesse mais colunas bastaria separá-las por vírgulas entre os parênteses, veja um exemplo:
|
1 |
INSERT INTO contatos (nome, telefone) VALUES ("Jose Santos", "572593478832"); |
Como os comandos posteriores ao de cima são iguais, apenas inserem novos dados na tabela, passemos aos útlimos comandos:
|
1 |
imprimaf("O ultimo id inserido é: %d\n", con:ultimo_id() ); |
Enfim, para pegar o último Id inserido use esta função acima:
con:ultimo_id();
Parâmetros: vazio;
Retornos: número prisma representando o valor do último id;
Por fim fechamos a conexão e finalizamos o programa:
|
1 2 3 |
con:feche(); retorne 0; fim |
A esta altura você já deve estar se questionando: como faço para inserir dados dinamicamente em tempo de execução usando variáveis.
A resposta é mais simples do que você imagina: lembra do operador de unir strings .. , pois é, use-o. Lembra da função string.formate(), use-a também.
Ex.:
Usando string.formate();
|
1 2 3 4 5 6 7 8 9 10 |
função insira_bd(con,tab_nome,col_nome,col_valor) local cmd_insira = "INSERT INTO %s(%s) VALUES('%s')"; cmd_exec = string.formate(cmd_insira,tab_nome,col_nome, col_valor); local err = con:exec(cmd_exec); se err entao retorne err; senao retorne nulo; fim fim |
Usando operador de união de strings:
|
1 2 3 4 5 6 7 8 9 |
função insira_bd(con,tab_nome,col_nome,col_valor) local cmd_insira = "INSERT INTO " .. tab_nome .. "(" .. col_nome .. ") VALUES('" .. col_valor .. "')"; local err = con:exec(cmd_insira); se err entao retorne err; senao retorne nulo; fim fim |
É claro que os códigos acima não tem nenhum tratamento de erro com os parâmetros recebidos, imagine se ‘con’ ou outro parâmetro fosse nulo! Geraria um erro fatal.
Você mesmo pode fazer o tratamento de erro, o código é simples:
se con == nulo entao retorne nulo fim; e assim com os demais parâmetros.
6 – Obtendo o nome das colunas
As vezes você não saberá quais colunas tem uma tabela em um banco de dados. Para descobrir os nomes basta usar um comando específico do MySQL:
local col = resultado->obt_coluna();
Veja um exemplo completo de uso:
Salve como nome_col.prisma
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 |
//pegando os nomes das colunas: local sql = inclua'mysql' funcao tem_erro(con,err,str) se err entao con->feche(); erro("Erro: " .. err); senao local str = str ou ''; imprima(str); fim fim funcao principal() local host, user, senha, bd = 'localhost','usuario','12345','testedb'; local sock = '/opt/lampp/var/mysql/mysql.sock';//elimine essa linha se seu servidor MySQL for Windows. local con, err = sql.conecte(host,user,senha,bd,3306,sock); tem_erro(con,err,'conexao realizada'); err = con->exec("SELECT * FROM Carros LIMIT 3");//Limite de 3 itens a serem lidos. tem_erro(con,err,'Tabela selecionada limite 3'); local resultado, err = con->obt_resultado();//pegando o resultado da string executada. tem_erro(con,err); local lin; local col = resultado->obt_coluna(); poe'Nome das colunas:\n--------------------' para i,v em ipares(col) inicio imprimaf("%s ", v); fim poe'\n--------------------'; enquanto 1 inicio//laco infinito local lin = resultado->obt_linha(); se lin entao para i,v em ipares(lin) inicio imprimaf("%s ", v); fim poe''; senao quebre;//acabou as linhas, interrompe o laço. fim fim resultado->feche(); con->feche(); retorne 0; fim//fim principal(); |
Detalhes:
Vamos pular o que já foi explicado, a novidade aqui é:
|
1 |
err = con->exec("SELECT * FROM Carros LIMIT 3"); |
Executa a string de comando MySQL:
|
1 |
"SELECT * FROM Carros LIMIT 3" |
Seleciona tudo da tabela Carros com o limite de 3 linhas.
|
1 |
local resultado, err = con->obt_resultado(); |
Acima usamos a função para obter o resultado da execução do comando MySQL.
|
1 |
local col = resultado->obt_coluna(); |
Aqui em cima pegamos os nomes das colunas existentes na tabela Carros. O retorne é uma tabela.
Esta tabela contém índices e cada um deles contém o nome da coluna.
Ex.:
col[1] = ‘nome coluna1’;
col[2] = ‘nome coluna2’;
etc.
O número de elementos da tabela corresponde ao número de colunas existentes, portanto podemos saber este número usando o operador de tamanho: num_col = #col;
|
1 2 3 |
para i,v em ipares(col) inicio imprimaf("%s ", v); fim |
Acima usamos um laço de repetição ‘para’ e imprimimos cada elemento da tabela ‘col’ correspondente ao nome de cada coluna.
Abaixo fazemos o mesmo com as linhas (já foi explicado nos exemplos anteriores!)
|
1 2 3 4 5 6 7 8 9 10 |
enquanto 1 inicio//laco infinito local lin = resultado->obt_linha(); se lin entao para i,v em ipares(lin) inicio imprimaf("%s ", v); fim poe''; senao quebre;//acabou as linhas, interrompe o laço. fim |
Com cuidado fechamos os objetos abertos e finalizamos retornando 0 ao sistema operacional:
|
1 2 3 |
resultado->feche(); con->feche(); retorne 0; |
7 – Executando múltiplos comandos MySQL
Caso você queira é possível executar de uma só vez múltiplos comandos, veja abaixo o exemplo:
Salve como multi_cmd.prisma
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 |
//multiplos comandos sql local sql = inclua'mysql' funcao principal() local host = 'localhost'; local user = 'usuario'; local senha = '12345'; local sock = '/opt/lampp/var/mysql/mysql.sock';//apaque esta linha se seu servidor Xampp for windows. local nome_bd = 'testedb'; local porta = 3306; local modo_mult = sql.CLIENTE_MULTI_CMD; //os outro parametros sao opcionais, mas agora precisamos deles: local con, err = sql.conecte(host, user, senha, nome_bd,porta,sock, modo_mult); tem_erro(con,err,'conexao realizada, modo multi_cmd'); //como definimos CLIENTE_MULTI_CMD //entao podemos definir multiplos comando sql numa mesma execução, veja: err = con:exec("SELECT Nome FROM Carros WHERE Id=2;\ SELECT Nome FROM Carros WHERE Id=3;\ SELECT Nome FROM Carros WHERE Id=6"); tem_erro(con,err,'executando comando sql'); //obtendo os valores: local status = 0; enquanto status == 0 inicio local resultado, err = con:obt_resultado(); tem_erro(con,err); local lin = resultado:obt_linha(); se lin e status == 0 entao imprimaf("%s ", lin[1]); poe''; resultado:feche();//fechando o resultado para pegar o proximo comando. status = con:proximo();//enquanto houver proximo comando o retorno é 0; fim se status > 0 entao erro("Erro: ", con:erro() ); fim; fim se resultado entao resultado:feche(); fim con:feche(); retorne 0; fim //fim principal() funcao tem_erro(con,err,str) se err entao con:feche(); erro("Erro no MySql: " .. err); senao se str entao imprima(str); fim fim fim |
Detalhes:
A novidade é o uso da seguinte variável:
|
1 |
local modo_mult = sql.CLIENTE_MULTI_CMD; |
Significa Cliente multiplos comandos.
Esta variável é passada como o último parâmetro para a função de conexão, ela é um flag que muda a configuração da conexão neste caso faz com que a conexão com o servidor aceite múltiplos comandos em uma única string.
Veja a função de conexão:
|
1 |
local con, err = sql.conecte(host, user, senha, nome_bd,porta,sock, modo_mult); |
|
1 2 3 |
err = con:exec("SELECT Nome FROM Carros WHERE Id=2;\ SELECT Nome FROM Carros WHERE Id=3;\ SELECT Nome FROM Carros WHERE Id=6"); |
A função acima executa a seguinte string MySQL:
|
1 2 3 |
"SELECT Nome FROM Carros WHERE Id=2;\ SELECT Nome FROM Carros WHERE Id=3;\ SELECT Nome FROM Carros WHERE Id=6" |
Na string acima selecionamos várias linhas com Id igual a 2, 3 e 6.
Múltiplos comandos geram múltiplos resultados.
|
1 2 |
local status = 0; enquanto status == 0 inicio |
Para percorrer todos os resultados iniciamos um laço enquanto cujo teste condicional é status == 0;. A variável status é usada para testar se há mais resultados ou não, o retorno deve sempre ser zero ou outro número quando não houver mais retornos de resultados.
|
1 |
local resultado, err = con:obt_resultado(); |
Acima obtemos o primeiro resultado do laço enquanto.
|
1 |
local lin = resultado:obt_linha(); |
Neste trecho obtemos a lin (ou nulo caso não haja linha no retorno);
|
1 |
se lin e status == 0 entao |
Testa se lin é uma linha válida e se status indica resultado válido.
|
1 2 |
imprimaf("%s ", lin[1]); poe''; |
Caso lin seja válida e status zero, podemos ler imprimir a linha. Neste caso apenas o valor da coluna 1;
O poe” é para pular uma linha no terminal ou cmd.
|
1 |
resultado:feche(); |
Devemos fechar o resultado para pegarmos o próximo!
|
1 |
status = con:proximo(); |
A função acima passa para o próximo resultado. Se status for igual a zero então temos um novo resultado válido, bastando usar novamente a função con:obt_resultado() para reiniciar o processo, isso é feito com o laço de repetição ‘enquanto’;
status = conexao:proximo();
Parâmetro: vazio;
Retornos:
1 – status: número que indica sucesso se for igual a zero ou erro (não há mais resultados) se for maior que zero.
|
1 |
se status > 0 entao erro("Erro: ", con:erro() ); fim; |
Acima temos o teste para continuar ou interromper o laço ‘enquanto’;
Detalhe aqui para a função erro() do MySQL:
|
1 |
con:erro() |
Retorna uma string descrevendo o último erro se houver.
Após isso finalizamos a função principal() retornando zero ao sistema operacional.
|
1 2 |
retorne 0; fim //fim principal() |
Abaixo temos a implementação da função que trata dos erros:
|
1 2 3 4 5 6 7 8 9 10 |
funcao tem_erro(con,err,str) se err entao con:feche(); erro("Erro no MySql: " .. err); senao se str entao imprima(str); fim fim fim |
8 – Colocando uma imagem no banco de dados
A lógica é abrir a imagem em modo binario, ler todo o conteúdo, codificá-la para evitar erros de caracteres especiais e inseri-la em uma tabela do MySQL.
Vamos ao código:
Salve como insere_img.prisma
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 |
//gravando imagem no bd local sql = inclua'mysql' funcao principal() local a = es.abra('img.jpg','leiturabin'); se a entao txt = a:leia("*t");// *t = lê tudo. a:feche(); senao erro("Não foi possivel abrir a imagem"); fim //abrindo banco de dados: local host = 'localhost'; local user = 'usuario'; local senha = '12345'; local bd = 'testedb'; local porta = 3306; local sock = '/opt/lampp/var/mysql/mysql.sock';//apague esta linha se seu servidor Xampp for Windows. local con, err = sql.conecte(host, user, senha, bd,porta,sock); tem_erro(con,err); //convertendo a string binaria da imagem para formato seguro do sql: local imgstr = string.base64(txt);//codifica a string em base64 evitando conflitos de caracteres especiais. imprima( imgstr); //colocando a string da imagem dentro do comando sql usando string.formate(); local sql_cmd = string.formate("INSERT INTO Filosofos(Id, Name) VALUES(10 , '%s')", imgstr); //imgstr ficara no lugar de %s dentro da primeira string err = con:exec("DROP TABLE IF EXISTS Filosofos"); tem_erro(con,err); sql_crie_tab = "CREATE TABLE Filosofos(Id INT PRIMARY KEY AUTO_INCREMENT, Name TEXT)"; err = con:exec(sql_crie_tab); tem_erro(con,err); err = con:exec(sql_cmd);//real_exec para dados binarios, senao nao funciona. tem_erro(con,err,'\nDado gravado com sucesso!'); con:feche(); retorne 0; fim //fim principal() funcao tem_erro(con,err,str) se err entao con:feche(); erro( err ); senao se str entao imprima(str) fim; fim fim |
Detalhes:
|
1 2 3 4 5 6 7 |
local a = es.abra('img.jpg','leiturabin'); se a entao txt = a:leia("*t");// *t = lê tudo. a:feche(); senao erro("Não foi possivel abrir a imagem"); fim |
Neste ponto abrimos o arquivo da imagem em modo leitura binária usando funções da biblioteca de entrada e saída ‘es’. (troque img.jpg pelo nome de sua imagem alvo.)
Verificamos se a imagem foi aberta, caso sim, lemos o todo o conteúdo e fechamos o objeto do arquivo aberto, caso contrário (senao) uma mensagem de erro é impressa finalizando o programa.
|
1 2 |
local con, err = sql.conecte(host, user, senha, bd,porta,sock); tem_erro(con,err); |
Após criar as variáveis fazemos a conexão;
|
1 |
local imgstr = string.base64(txt);//codifica a string em base64 evitando conflitos de caracteres especiais. |
Antes de inserirmos string da imagem lida, devemos codificá-la para não dar erro de caracteres. Usamos para isso a função string.base64() que recebe uma string e retorna sua codificação em base 64.
|
1 |
local sql_cmd = string.formate("INSERT INTO Filosofos(Id, Name) VALUES(10 , '%s')", imgstr); |
Na função acima criamos a string comando para inserir a imagem no banco de dados. Para colocar a string da imagem dentro da string de comandos MySQL usamos a função string.formate() em que o %s é substituído pelo segundo parâmetro. Você poderia facilmente, também, usar os operadores de união de strings para uni-las (os ‘..’);
|
1 |
err = con:exec("DROP TABLE IF EXISTS Filosofos"); |
Apagamos a tabela caso ela exista.
|
1 2 |
sql_crie_tab = "CREATE TABLE Filosofos(Id INT PRIMARY KEY AUTO_INCREMENT, Name TEXT)"; err = con:exec(sql_crie_tab); |
Criamos a tabela Filosofos com duas colunas, a primeira ‘Id’ como chave de auto-incremento, e a segunda ‘Name’ tipo TEXT.
|
1 |
err = con:exec(sql_cmd); |
Enfim, inserimos o dado com a função acima, lembre-se que sql_cmd foi criada mais acima com a string da imagem.
|
1 2 |
con:feche(); retorne 0; |
Por fim, fechamos a conexão e retornamos 0 da função principal() para o sistema operacional.
9 – Lendo a imagem inserida no banco de dados
Não teria sentido inserir uma imagem no banco de dados se não fosse possível obtê-la posteriormente, é isso o que vamos fazer neste exemplo.
Obtendo a imagem inserida conforme o exemplo anterior.
Salve como lendo_img.prisma
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
//recuperando a imagem gravada com o ex_8 local sql = inclua'mysql' funcao principal() //conectando com o banco de dados: local sock = '/opt/lampp/var/mysql/mysql.sock';//apenas em servidor linux. (win nao); local con, err = sql.conecte('localhost','usuario','senha','testedb',nulo,sock); tem_erro(con,err,'conexao realizada'); //recuperando a imagem: err = con:exec("SELECT Name FROM Filosofos WHERE Id=10"); tem_erro(con,err,'selecionado id 10 com a imagem'); local resultado, err = con:obt_resultado(); tem_erro(con,err); local lin = resultado:obt_linha(); se lin entao local a = es.abra('img_copia.jpg','escritabin'); //a:escreva(lin[1]); //se usou con:escape_string(txt) no exemplo anterior use esta funcao. a:escreva( string.dec_base64(lin[1]) );//se usou a base64 entao decodifique antes de gravar. a:feche(); fim resultado:feche(); con:feche(); retorne 0; fim //fim principal() funcao tem_erro(con,err,str) se err entao con:feche(); imprima(err); leia(); sis.saia(1); senao se str entao imprima(str) fim; fim fim |
Detalhes:
Vamos à novidade
|
1 |
err = con:exec("SELECT Name FROM Filosofos WHERE Id=10"); |
Aqui selecionamos a coluna Id 10 onde inserimos a imagem.
Obs. Poderíamos criar uma tabela mais completa com campo Nome_imagem = ‘imagem1.jpj” ; Mas como é um exemplo simplificado deixemos com está.
|
1 |
local resultado, err = con:obt_resultado(); |
Obtendo o objeto resultado da execução MySQL.
|
1 |
local lin = resultado:obt_linha(); |
Obtendo o valor da linha selecionada.
|
1 2 3 4 5 6 |
se lin entao local a = es.abra('img_copia.jpg','escritabin'); //a:escreva(lin[1]); //se usou con:escape_string(txt) no exemplo anterior use esta funcao. a:escreva( string.dec_base64(lin[1]) );//se usou a base64 entao decodifique antes de gravar. a:feche(); fim |
Se lin for uma linha válida entao abrimos um arquivo em modo escrita binária e escrevemos dentro dele o valor de lin[1]. Antes, é claro, fazemos a decodificação base64 com a função string.dec_base64(). Esta função recebe uma string em codificação base64 e retorna seu valor decodificado.
O restante é igual aos exemplos anteriores e já foi explicado!
10 – Deletando valores da tabela do banco de dados
Salve como deleta.prisma
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
//apagando um dado de uma tabela do mysql inclua'mysql' funcao tem_erro(con,err) se err entao con->.feche(); imprima(err); sis.saia(0); leia(); fim fim local xstr = "DELETE from Carros where Id = 1;"//deleta da tabela Carros onde o Id for igual a 2; //conectando com o banco de dados: local sock = '/opt/lampp/var/mysql/mysql.sock';//apenas em servidor linux. (win nao); local con, err = sql.conecte('localhost','root','senha','testedb',3306,sock); err = con->exec(xstr); tem_erro(con,err); poe'Dado apagado com sucesso'; con->feche(); //fechando a conexao |
Detalhes:
|
1 |
local xstr = "DELETE from Carros where Id = 1;"//deleta da tabela Carros onde o Id for igual a 2; |
Essa é a string de comando MySQL que significa:
DELETE de Carros o valor onde id é igual a 1;
|
1 |
err = con->exec(xstr); |
E executamos a string após abrir devidamente o banco de dados.
Não se esqueça de fechar os objetos no fim do programa.
Obs.: note que não usamos a função principal() aqui, se quiser não precisa usá-la.
11 – Atualizando os dados de uma tabela
Imagine que você queira modificar um valor já existente no banco de dados, é o que faz o exemplo abaixo:
Salve como atualiza.prisma
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 |
//atualizando um dado do mysql local mysql = inclua'mysql'; funcao tem_erro(con,err) se err entao mysql.feche(con); imprima(err); sis.saia(0); leia(); fim fim sql_str = "UPDATE Carros set Nome = 'NADA_AQUI' , Preco = 0 where Id = 2;"; //conectando com o banco de dados: local sock = '/opt/lampp/var/mysql/mysql.sock';//apenas em servidor linux. (win nao); local con, err = mysql.conecte('localhost','root','senha','testedb',3306,sock); tem_erro(con,err); err = mysql.exec(con, sql_str); tem_erro(con,err); poe'Dado atualizado'; poe 'imprimindo' err = mysql.exec(con,"SELECT * FROM Carros"); res, err = mysql.obt_res(con);//a mesma funcao que mysql.obt_resultado, use qual preferir... tem_erro(con,err); local lin=''; enquanto lin inicio lin = mysql.obt_linha(res);//obtendo a linha do resultado. se lin entao para i,v em ipares(lin) inicio imprimaf("%s ", v); fim poe'';//pula uma linha na impressao. fim fim mysql.feche_resultado(res); mysql.feche(con); |
Detalhes:
|
1 |
sql_str = "UPDATE Carros set Nome = 'NADA_AQUI' , Preco = 0 where Id = 2;"; |
Essa é a string comando MySQL, leia da seguinte forma:
ATUALIZE Carros defina Nome = ‘NADA_AQUI’, Preco = 0 onde Id for igual a 2;
Ou seja, na linha com Id 2, as colunas Nome e Preco mudarão de valor.
|
1 |
err = mysql.exec(con, sql_str); |
Aqui em cima, executamos o comando de atualização do bd.
Nos comandos posteriores fazemos a leitura para ver o dado modificado, isso já foi explicado nos exemplos anteriores.
Obs.: como você pode ter percebido, é possível optar por não usar o estilo orientado a objeto passando explicitamente os objetos como parâmetro:
mysql.exec(con,sql_str); ao invés de con:exec(sql_str);
12 – Obtendo o nome das tabelas existentes em um banco de dados
Neste próximo exemplo demonstro como descobrir automaticamente o nome das tabelas de um bd.
Salve como nome_tab.prisma
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
//imagine um banco de dado, e vc não sabe sequer que tabelas estao gravadas nele. //com o codigo abaixo vc lista as tabelas existentes: local mysql=inclua'mysql' funcao tem_erro(con,err) se err entao mymysql.feche(con); imprima(err); sis.saia(0); leia(); fim fim //conectando com o banco de dados: local sock = '/opt/lampp/var/mysql/mysql.sock';//apenas em servidor linux. (win nao); local con, err = mysql.conecte('localhost','root','senha','testedb',3306,sock); tem_erro(con,err); err = mysql.exec(con, "SHOW TABLES" ); local res,err=mysql.obt_resultado(con); tem_erro(con,err); poe'Tabelas existentes:\n\n'; local lin=''; enquanto lin inicio lin=mysql.obt_linha(res); se lin entao para i,v em pares(lin) inicio imprimaf("%s ", v); fim poe''; fim fim mysql.feche_resultado(res); mysql.feche(con); leia(); |
Detalhes:
Não tem muito segredo, basta executar a string MySQL “SHOW TABLES” e depois pegar o resultado.
|
1 |
err = mysql.exec(con, "SHOW TABLES" ); |
Executando a string MySQL, depois de ter aberto devidamente o banco de dados.
|
1 |
local res,err=mysql.obt_resultado(con); |
Obtendo o objeto resultado na variável res.
|
1 2 3 4 5 6 7 8 9 |
enquanto lin inicio lin=mysql.obt_linha(res); se lin entao para i,v em pares(lin) inicio imprimaf("%s ", v); fim poe''; fim fim |
O laço ‘enquanto’ acima lê cada nome de tabela que houver.
13 – Excluindo tabelas do banco de dados
Salve como apaga_tab.prisma
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
//deletando tabela inteira de um banco de dado mysql: local mysql=inclua'mysql' funcao tem_erro(con,err) se err entao con:feche(); erro(err); fim fim //conectando com o banco de dados: local sock = '/opt/lampp/var/mysql/mysql.sock';//apenas em servidor linux. (win nao); local con, err = mysql.conecte('localhost','root','senha','testedb',nulo,sock); tem_erro(con,err); err = con:exec('DROP TABLE IF EXISTS Carros'); tem_erro(con,err); imprima("Tabela Carros foi deletada"); con:feche();//fechando a conexao leia(); |
Detalhes:
O comando para apagar a tabela é:
|
1 |
err = con:exec('DROP TABLE IF EXISTS Carros'); |
“APAGUE TABELA Carros SE EXISTIR;
Obs.: logicamente o usuário deve ter privilégios para deletar a tabela.
14 – Excluindo banco de dados
Necessário privilégios ao usuário.
Salve como deleta_bd.prisma
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
//deletando um banco de dados local mysql = inclua'mysql' funcao tem_erro(con,err) se err entao mysql.feche(con); erro(err); fim fim //conectando com o banco de dados: local sock = '/opt/lampp/var/mysql/mysql.sock';//apenas em servidor linux. (win nao); local con, err = mysql.conecte('localhost','usuario','senha','testedb',3306,sock); tem_erro(con,err); err = mysql.exec(con,"DROP DATABASE IF EXISTS testedb;"); tem_erro(con,err); poe'Banco de dados testedb apagado com sucesso!'; mysql.feche(con); leia(); |
Detalhes:
|
1 |
err = mysql.exec(con,"DROP DATABASE IF EXISTS testedb;"); |
“APAGUE BANCO_DE_DADOS testedb SE EXISTIR”
Exclui o banco de dados testedb.
15 – Limpando o Banco de Dados
Salve como limpa_bd.prisma
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 |
//eliminado todas as tabelas de um banco de dados: local mysql=inclua'mysql' funcao tem_erro(con,err) se err entao mysql.feche(con); imprima(err); leia(); sis.saia(1); fim fim //conectando com o banco de dados: local sock = '/opt/lampp/var/mysql/mysql.sock';//apenas em servidor linux. (win nao); local con, err = mysql.conecte('localhost','root','senha','testedb',3306,sock); err = mysql.exec(con, "SHOW TABLES");//basta pegar todas as tabelas existentes tem_erro(con,err); local res, err = mysql.obt_res(con); tem_erro(con,err); local lin = ''; enquanto lin inicio lin = mysql.obt_linha(res); se lin entao para i,v em ipares(lin) inicio imprima(v); err = mysql.exec(con,"DROP TABLE IF EXISTS " .. v );//e apagá-las uma a uma aqui. tem_erro(con,err); fim fim fim mysql.feche_res(res); mysql.feche(con); poe'Banco de dados foi limpo'; //todas as tabelas apagadas. leia(); |
Detalhes:
A ideia básica é listar os nomes de todas as tabelas e depois apagá-las uma a uma usando um laço.
|
1 |
err = mysql.exec(con, "SHOW TABLES");/ |
Aqui executamos a string que lista cada nome de tabela existente no banco de dados. Para pegar os valores devemos obter o objeto resultado:
|
1 |
local res, err = mysql.obt_res(con); |
Acima obtemos o objeto resultado na variável res.
|
1 2 3 4 5 6 7 8 9 10 |
enquanto lin inicio lin = mysql.obt_linha(res); se lin entao para i,v em ipares(lin) inicio imprima(v); err = mysql.exec(con,"DROP TABLE IF EXISTS " .. v );//e apagá-las uma a uma aqui. tem_erro(con,err); fim fim fim |
Com esse laço enquanto pegamos cada linha na variável lin e no laço ‘para’ interno pegamos os nomes de cada tabela e para cada nome executamos o comando que apaga tabelas:
|
1 |
err = mysql.exec(con,"DROP TABLE IF EXISTS " .. v ); |
Esse comando acima deleta as tabelas se existirem.
Obs.: é bom colocar o comando IF EXISTS pois se a tabela não existir e tentarmos apagá-la gera um erro fatal, e esse IF evita isso.
16 – Listando os nomes dos bancos de dados no servidor MySQL
Necessita privilégios de usuário root
Salve como lista_bd.prisma
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 |
//descobrindo dos bancos de dados criados no servidor... local mysql=inclua'mysql' funcao tem_erro(con,err) se err entao mysql.feche(con); imprima(err); sis.saia(0); leia(); fim fim local host = 'localhost'; local user = 'usuario'; local senha = '12345'; local porta = 3306; local sock = '/opt/lampp/var/mysql/mysql.sock';//apaque esta linha se seu servidor Xampp for windows. local con, err = mysql.conecte(host,user,senha,nulo,porta,sock); tem_erro(con,err); poe'\nBancos criados neste servidor Mysql:\n\n'; err = mysql.exec(con, "SHOW DATABASES;"); tem_erro(con,err); res,err = mysql.obt_resultado(con); tem_erro(con,err); local lin=''; enquanto lin inicio lin = mysql.obt_linha(res); se lin entao para i,v em pares(lin) inicio imprimaf("%s ", v); fim poe''; fim fim mysql.feche_resultado(res); mysql.feche(con); leia(); |
Detalhes:
|
1 |
err = mysql.exec(con, "SHOW DATABASES;"); |
String comando MySQL que lista todos os bancos de dados.
|
1 |
res,err = mysql.obt_resultado(con); |
Depois da execução, obtemos o objeto resultado na variável res.
|
1 2 3 4 5 6 7 8 9 10 |
local lin=''; enquanto lin inicio lin = mysql.obt_linha(res); se lin entao para i,v em pares(lin) inicio imprimaf("%s ", v); fim poe''; fim fim |
Com o laço ‘enquanto’ percorremos todos os resultados o imprimimos os valores.
17 – Contando o número de linhas de uma tabela
Há uma maneira rápida e fácil de contar linhas de uma tabela de banco de dados MySQL.
Salve como num_lin.prisma
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
//numero de linhas inseridas em uma tabela: local mysql=inclua'mysql' funcao tem_erro(con,err) se err entao mysql.feche(con); imprima(err) leia(); sis.saia(0); fim fim sock = '/opt/lampp/var/mysql/mysql.sock'; local con, err = mysql.conecte('localhost', 'usuario','senha','testedb',3306,sock); tem_erro(con,err); poe'\nNumero de Linhas em Carros:\n\n'; err = con:exec( "select count(*) from Carros;"); tem_erro(con,err); res,err = con:obt_resultado(); tem_erro(con,err); local lin=''; enquanto lin inicio lin = res:obt_linha(); se lin entao para i,v em pares(lin) inicio imprimaf("A tabela Carros tem ::%s:: linhas de dados\n", v); fim fim fim mysql.feche_resultado(res); mysql.feche(con); leia(); |
Detalhes:
|
1 |
err = con:exec( "select count(*) from Carros;"); |
Este comando conta o número de linhas inseridas em Carros.
Obs. Note que o comando MySQL está em minúscula e a execução ocorre sem problemas.
|
1 2 3 4 5 6 7 8 9 |
local lin=''; enquanto lin inicio lin = res:obt_linha(); se lin entao para i,v em pares(lin) inicio imprimaf("A tabela Carros tem ::%s:: linhas de dados\n", v); fim fim fim |
Com o laço ‘enquanto’ pegamos o valor selecionado. Nem precisaríamos do laço visto que o retorno é um apenas com o valor número de linhas da tabela.
18 – Obtendo tipo de codificação de caracteres do MySQL
Salve como codi.prisma
|
1 2 3 4 5 6 7 8 9 |
local sql = inclua'mysql' local sock = '/opt/lampp/var/mysql/mysql.sock'; local con, err = sql.conecte('localhost','usuario','12345',nulo,nulo,sock); se err entao imprima(err); con:feche(); leia(); sis.saia(0); fim tab = con:obt_car_info(); para c,v em pares(tab) inicio imprima(c,':',v) fim |
|
1 |
tab = con:obt_car_info(); |
Com essa função acima obtemos uma tabela com toda descrição da codificação.
|
1 2 3 |
para c,v em pares(tab) inicio imprima(c,':',v) fim |
E por meio comando ‘para’ exibimos cada elemento da coluna no terminal.
Chegamos ao final do tutorial. Espero que ele tenha sido muito útil.
Vou passar uns links sobre comandos MySQL como dica para quem quiser aprimorar seus conhecimentos:
https://www.todoespacoonline.com/w/2014/10/comandos-basicos-mysql/
FIM
Att. Adalberto