Manual de SQL. Tutorial Utilizar SQL em 4D Comandos SQL Regras de sintaxe Transações Funções Anexos Lista alfabética dos comandos

Transcrição

1 Manual de SQL Tutorial Utilizar SQL em 4D Comandos SQL Regras de sintaxe Transações Funções Anexos Lista alfabética dos comandos

2 Tutorial Introdução Receber o resultado de um pedido SQL em uma variável Utilizar a cláusula WHERE Receber o resultado de um pedido SQL em um array Utilizar CAST Utilizar a cláusula ORDER BY Utilizar a cláusula GROUP BY Utilizar funçõs estadísticas Utilizar a cláusula HAVING Chamar os métodos 4D desde o código SQL Joins Utilizar Alias Subconsultas Seguimento e depuração do código SQL Data Definition Language Conexões Externas Conexão ao motor SQL 4D via o driver ODBC

3 Introdução O SQL (Structured Query Language) é uma ferramenta de criação, organização, gestão e recuperação de dados armazenados em um banco de dados do computador. SQL não é um sistema de gerenciamento de banco de dados, ou um produto independente, no entanto, SQL é uma parte integral de um sistema de gestão do banco de dados, uma língua e uma ferramenta utilizada para comunicar-se com este sistema. O objetivo deste tutorial não é ensiná-lo a trabalhar com SQL (para isso pode ser encontrada documentação e links na Internet), nem ensinar como você usar e/ou programar em 4D. Em vez disso, seu objetivo é mostrar como trabalhar com código SQL dentro do código 4D, como recuperar dados usando comandos SQL, como passar parâmetros e como obter resultados depois de uma consulta SQL. do banco de dados que acompanha este tutorial Todos os exemplos que são detalhados neste documento foram provados e verificados totalmente em um dos bancos de dados de exemplo chamado "4D SQL Code Samples" que pode baixar de nosso servidor ftp. (ftp://ftppublic.4d.fr/documents/products_documentation/lastversions/line_12/4d_sql_code_samples.zip). A estrutura é a seguinte: A tabela MOVIES contém informação sobre 50 filmes, incluindo título, diretor, categoria (Ação, Animação, Comédia, Crime, Drama, etc), o ano de saída, se tem ou não têm legendas, um breve resume, uma foto de seu cartaz, o tipo de meio (DVD, VHS, DivX), se é em branco e preto, um blog guardado em um BLOB e o número de entradas vendidas. A tabela ACTORS contém informação sobre os atores dos filmes tais como identificação, nomes e sobrenomes, comentários e o ID da cidade onde nasceu o ator. A tabela CITIES contém informação sobre o nome e ID das cidades onde os atores nasceram. A tabela MOVIE_ACTOR se utiliza para estabelecer uma relação de Muitos a Muitos entre as tabelas MOVIES e ACTORS. Toda a informação que necessita para lançar os exemplos descritos no tutorial se encontra na seguinte janela principal que pode acessar selecionando o comando de menu Demo SQL>Show samples:

4 Receber o resultado de um pedido SQL em uma variável Comecemos por uma pesquisa simples: queremos saber quantas filmes estão em nossa videoteca. Na linguagem 4D, o código seria: C_LONGINT($AllMovies) $AllMovies:=0 ALL RECORDS([MOVIES]) $AllMovies:=Records in selection([movies]) ALERT("A videoteca contém "+String($AllMovies)+"filmes") A primeira forma de interagir de uma forma similar com o motor SQL é localizar o pedido entre as etiquetas Begin SQL e End SQL. Desta forma, a pesquisa anterior se converte em: C_LONGINT($AllMovies) $AllMovies:=0 Begin SQL SELECT COUNT(*) FROM MOVIES INTO <<$AllMovies>> End SQL ALERT("A videoteca contém "+String($AllMovies)+"filmes") Como pode ver, pode recuperar o resultado da pesquisa em uma variável (em nosso caso $AllMovies) que está entre os símbolos "<<" e ">>". Outra forma de referenciar todo tipo de expressão 4D valida (variável, campo, array, expressão ) é colocar dois pontos ":" antes da expressão: C_LONGINT($AllMovies) $AllMovies:=0 Begin SQL SELECT COUNT(*) FROM MOVIES INTO :$AllMovies End SQL ALERT("A videoteca contém "+String($AllMovies)+"filmes") Deve ser prestada atenção especial as variáveis interprocesso, onde a notação é um pouco diferente: deve colocar uma variável interprocesso entre colchetes "[" e "]": C_LONGINT(<>AllMovies) <>AllMovies:=0 Begin SQL SELECT COUNT(*) FROM MOVIES INTO <<[<>AllMovies]>> End SQL ALERT("A videoteca contém "+String(<>AllMovies)+"filmes") A segunda forma de interagir com o motor SQL é utilizar os comandos SQL genéricos integrados (compatíveis ODBC). A pesquisa simples se converte em: C_LONGINT($AllMovies) $AllMovies:=0 ` Inicializa uma conexão com o motor SQL interno

5 SQL LOGIN(SQL_INTERNAL;"";"") ` Executa a pesquisa e devolve o resultado na variável $AllMovies SQL EXECUTE("SELECT COUNT(*) FROM MOVIES";$AllMovies) ` Recupera todos os registros encontrados SQL LOAD RECORD(SQL all records) ` Fecha a conexão SQL LOGOUT ALERT("A videoteca contém "+String($AllMovies)+"filmes") Para maior informação sobre os comandos SQL genéricos, consulte o capítulo SQL do manual de Linguagem 4D. A terceira forma de interagir com o motor SQL é utilizar o comando 4D QUERY BY SQL. Neste caso, a pesquisa simples se converte em: C_LONGINT($AllMovies) $AllMovies:=0 QUERY BY SQL([MOVIES];"ID <> 0") $AllMovies:=Records in selection([movies]) ALERT("A videoteca contém "+String($AllMovies)+"filmes") O comando QUERY BY SQL executa uma pesquisa de tipo SELECT que pode ser escrita desta forma: SELECT * FROM mytable WHERE <SQL_Fórmula> mytable é o nome da tabela passada no primeiro parâmetro e SQL_Formula é o texto da pesquisa passado como segundo parâmetro: QUERY BY SQL(myTable;SQL_Formula) Em nosso caso não há cláusula WHERE, então forçamos uma: "ID <> 0". O equivalente da pesquisa em código SQL é: SELECT * FROM MOVIES WHERE ID <> 0 A quarta forma de interagir com o motor SQL é utilizar o comando SQL dinâmico EXECUTE IMMEDIATE. O código se converte em: C_LONGINT($AllMovies) $AllMovies:=0 C_TEXT($tQueryTxt) $tquerytxt:="select COUNT(*) FROM MOVIES INTO :$AllMovies" Begin SQL EXECUTE IMMEDIATE :$tquerytxt; End SQL ALERT("A videoteca contém "+String($AllMovies)+"filmes") Atenção: Você pode ver que neste último exemplo, utilizamos variáveis processo. Isto é necessário se quer utilizar a base em modo compilado. Neste contexto, em efeito, não é possível utilizar variáveis locais com o comando EXECUTE IMMEDIATE. Para provar todos estes exemplos, lance a base "4D SQL Code Samples" e mostre a caixa de diálogo principal. A esquerda da janela, pode escolher o modo de interrogação do motor de 4D:

6 Depois pressione o botão SQL query results in variables.

7 Utilizar a cláusula WHERE Se agora queremos saber quantos filmes realizados desde 1960 estão na videoteca. O código 4D seria: C_LONGINT($NoMovies) $NoMovies:=0 REDUCE SELECTION([MOVIES];0) QUERY([MOVIES];[MOVIES]Year_of_Movie>=1960) $NoMovies:=Records in selection([movies]) ALERT("A videoteca contém "+String($NoMovies)+"filmes realizados desde 1960") Utilizando o código SQL: C_LONGINT($NoMovies) $NoMovies:=0 REDUCE SELECTION([MOVIES];0) Begin SQL SELECT COUNT(*) FROM MOVIES WHERE Year_of_Movie >= 1960 INTO :$NoMovies; End SQL ALERT("A videoteca contém "+String($NoMovies)+"filmes realizados desde 1960") Utilizando os comandos SQL genéricos: C_LONGINT($NoMovies) $NoMovies:=0 REDUCE SELECTION([MOVIES];0) SQL LOGIN(SQL_INTERNAL;"";"") SQL EXECUTE("SELECT COUNT(*) FROM MOVIES WHERE Year_of_Movie >= 1960";$NoMovies) SQL LOAD RECORD(SQL all records) SQL LOGOUT ALERT("A videoteca contém "+String($NoMovies)+"filmes realizados desde 1960") Utilizando o comando QUERY BY SQL: C_LONGINT($NoMovies) $NoMovies:=0 REDUCE SELECTION([MOVIES];0) QUERY BY SQL([MOVIES];"Year_of_Movie >= 1960") $NoMovies:=Records in selection([movies]) ALERT("A videoteca contém "+String($NoMovies)+"filmes realizados desde 1960") Utilizando o comando SQL EXECUTE IMMEDIATE: C_LONGINT($NoMovies) C_TEXT($tQueryTxt) $NoMovies:=0

8 REDUCE SELECTION([MOVIES];0) $tquerytxt:="select COUNT(*) FROM MOVIES WHERE Year_of_Movie >= 1960 INTO :$NoMovies;" Begin SQL EXECUTE IMMEDIATE :$tquerytxt; End SQL ALERT("A videoteca contém "+String($NoMovies)+" filmes realizados desde 1960") Como na seção anterior, para provar todos os exemplos, simplesmente lance a base "4D SQL Code Samples" e vá até a janela principal. Escolha o modo de interrogação do motor de 4D e faça clique no botão WHERE clause.

9 Receber o resultado de um pedido SQL em um array Agora queremos passar uma variável que contém o ano a pesquisa SQL (e não o ano) e recuperar a lista de todas os filmes lançados em 1960 o mais recentemente. Além disso, para cada filme encontrado, também queremos informação como o ano, título, diretor, meios utilizados e boletos vendidos. A solução consiste em receber esta informação em arrays ou em um list box. A pesquisa inicial no código 4D seria: ARRAY LONGINT(aSoldTickets;0) ARRAY INTEGER(aMovieYear;0) ARRAY TEXT(aTitles;0) ARRAY TEXT(aDirectors;0) ARRAY TEXT(aMedias;0) C_LONGINT($MovieYear) REDUCE SELECTION([MOVIES];0) $MovieYear:=1960 QUERY([MOVIES];[MOVIES]Year_of_Movie>=$MovieYear) SELECTION TO ARRAY([MOVIES]Year_of_Movie;aMovieYear;[MOVIES]Title;aTitles;[MOVIES]Director;aDirectors; [MOVIES]Media;aMedias;[MOVIES]Sold_Tickets;aSoldTickets) ` Inicia o resto das colunas do list box com o propósito de visualizar a informação ARRAY LONGINT(aNrActors;Size of array(amovieyear)) Utilizando código SQL: ARRAY LONGINT(aSoldTickets;0) ARRAY INTEGER(aMovieYear;0) ARRAY TEXT(aTitles;0) ARRAY TEXT(aDirectors;0) ARRAY TEXT(aMedias;0) C_LONGINT($MovieYear) $MovieYear:=1960 Begin SQL SELECT Year_of_Movie, Title, Director, Media, Sold_Tickets FROM MOVIES WHERE Year_of_Movie >= :$MovieYear INTO :amovieyear, :atitles, :adirectors, :amedias, :asoldtickets; End SQL ` Inicia o resto das colunas do list box com o propósito de visualizar a informação ARRAY LONGINT(aNrActors;Size of array(amovieyear)) Como você pode ver: Podemos passar uma variável ($MovieYear) a pesquisa SQL usando a mesma notação que para a recepção de parâmetros. O resultado da pesquisa SQL é guardada nos arrays amovieyear, atitles, adirectories, amedias e asoldtickets. Os resultados são mostrados na janela principal de duas formas: Utilizando arrays agrupados: Utilizando um list box com colunas com os mesmos nomes: Utilizando comandos SQL genéricos: ARRAY LONGINT(aSoldTickets;0)

10 ARRAY INTEGER(aMovieYear;0) ARRAY TEXT(aTitles;0) ARRAY TEXT(aDirectors;0) ARRAY TEXT(aMedias;0) C_LONGINT($MovieYear) C_TEXT($tQueryTxt) REDUCE SELECTION([MOVIES];0) $MovieYear:=1960 SQL LOGIN(SQL_INTERNAL;"";"") $tquerytxt:="" $tquerytxt:=$tquerytxt+"select Year_of_Movie, Title, Director, Media, Sold_Tickets" $tquerytxt:=$tquerytxt+" FROM MOVIES" $tquerytxt:=$tquerytxt+" WHERE Year_of_Movie >= :$MovieYear" SQL EXECUTE($tQueryTxt;aMovieYear;aTitles;aDirectors;aMedias;aSoldTickets) SQL LOAD RECORD(SQL all records) SQL LOGOUT ` Inicia o resto das colunas do list box com o propósito de visualizar a informação ARRAY LONGINT(aNrActors;Size of array(amovieyear)) Utilizando o comando QUERY BY SQL: ARRAY LONGINT(aSoldTickets;0) ARRAY INTEGER(aMovieYear;0) ARRAY TEXT(aTitles;0) ARRAY TEXT(aDirectors;0) ARRAY TEXT(aMedias;0) C_LONGINT($MovieYear) REDUCE SELECTION([MOVIES];0) $MovieYear:=1960 QUERY BY SQL([MOVIES];"Year_of_Movie >= :$MovieYear") SELECTION TO ARRAY([MOVIES]Year_of_Movie;aMovieYear;[MOVIES]Title;aTitles;[MOVIES]Director;aDirectors; [MOVIES]Media;aMedias;[MOVIES]Sold_Tickets;aSoldTickets) ` Inicia o resto das colunas do list box com o propósito de visualizar a informação ARRAY LONGINT(aNrActors;Size of array(amovieyear)) Utilizando o comando SQL EXECUTE IMMEDIATE: ARRAY LONGINT(aSoldTickets;0) ARRAY INTEGER(aMovieYear;0) ARRAY TEXT(aTitles;0) ARRAY TEXT(aDirectors;0) ARRAY TEXT(aMedias;0) C_LONGINT($MovieYear) C_TEXT($tQueryTxt) REDUCE SELECTION([MOVIES];0) $MovieYear:=1960 $tquerytxt:="" $tquerytxt:=$tquerytxt+"select Year_of_Movie, Title, Director, Media, Sold_Tickets" $tquerytxt:=$tquerytxt+" FROM MOVIES" $tquerytxt:=$tquerytxt+" WHERE Year_of_Movie >= :$MovieYear" $tquerytxt:=$tquerytxt+" INTO :amovieyear, :atitles, :adirectors, :amedias, :asoldtickets;" Begin SQL EXECUTE IMMEDIATE :$tquerytxt; End SQL ` Inicia o resto das colunas do list box com o propósito de visualizar a informação ARRAY LONGINT(aNrActors;Size of array(amovieyear)) Para provar todos os exemplos anteriores, lance a base "4D SQL Code Samples" e vá até a janela principal. Escolha o modo de consulta e pressione o botão SQL query results in arrays.

11

12 Utilizar CAST A linguagem SQL têm regras bastante restritivas sobre a combinação de dados de diferentes tipos nas expressões. Geralmente, o SMBD (DBMS) é encarregado da conversão automática. No entanto, o padrão SQL requer que o SMDB gere um erro caso se tentar comparar números com cadeias de caracteres. Neste contexto, a expressão CAST é muito importante, especialmente quando utiliza SQL dentro de uma linguagem de programação cujos tipos de dados não coincidem com os tipos suportados pelo padrão SQL. Você vai encontrar a continuação a pesquisa da seção modificada ligeiramente para poder utilizar a expressão CAST. O código 4D inicial seria: ARRAY LONGINT(aSoldTickets;0) ARRAY INTEGER(aMovieYear;0) ARRAY TEXT(aTitles;0) ARRAY TEXT(aDirectors;0) ARRAY TEXT(aMedias;0) REDUCE SELECTION([MOVIES];0) $MovieYear:=Num("1960") QUERY([MOVIES];[MOVIES]Year_of_Movie>=$MovieYear) SELECTION TO ARRAY([MOVIES]Year_of_Movie;aMovieYear;[MOVIES]Title;aTitles;[MOVIES]Director;aDirectors; [MOVIES]Media;aMedias;[MOVIES]Sold_Tickets;aSoldTickets) ` Inicia o resto das colunas do list box para mostrar a informação ARRAY LONGINT(aNrActors;Size of array(amovieyear)) Utilizando código SQL: ARRAY LONGINT(aSoldTickets;0) ARRAY INTEGER(aMovieYear;0) ARRAY TEXT(aTitles;0) ARRAY TEXT(aDirectors;0) ARRAY TEXT(aMedias;0) Begin SQL SELECT Year_of_Movie, Title, Director, Media, Sold_Tickets FROM MOVIES WHERE Year_of_Movie >= CAST('1960' AS INT) INTO :amovieyear, :atitles, :adirectors, :amedias, :asoldtickets; End SQL ` Inicia o resto das colunas do list box para mostrar a informação ARRAY LONGINT(aNrActors;Size of array(amovieyear)) Utilizando comandos SQL genéricos: ARRAY LONGINT(aSoldTickets;0) ARRAY INTEGER(aMovieYear;0) ARRAY TEXT(aTitles;0) ARRAY TEXT(aDirectors;0) ARRAY TEXT(aMedias;0) C_TEXT($tQueryTxt) REDUCE SELECTION([MOVIES];0) SQL LOGIN(SQL_INTERNAL;"";"") $tquerytxt:="" $tquerytxt:=$tquerytxt+"select Year_of_Movie, Title, Director, Media, Sold_Tickets" $tquerytxt:=$tquerytxt+" FROM MOVIES" $tquerytxt:=$tquerytxt+" WHERE Year_of_Movie >= CAST('1960' AS INT)"

13 SQL EXECUTE($tQueryTxt;aMovieYear;aTitles;aDirectors;aMedias;aSoldTickets) SQL LOAD RECORD(SQL all records) SQL LOGOUT ` Inicia o resto das colunas do list box para mostrar a informação ARRAY LONGINT(aNrActors;Size of array(amovieyear)) Utilizando o comando QUERY BY SQL: ARRAY LONGINT(aSoldTickets;0) ARRAY INTEGER(aMovieYear;0) ARRAY TEXT(aTitles;0) ARRAY TEXT(aDirectors;0) ARRAY TEXT(aMedias;0) REDUCE SELECTION([MOVIES];0) QUERY BY SQL([MOVIES];"Year_of_Movie >= CAST('1960' AS INT)") SELECTION TO ARRAY([MOVIES]Year_of_Movie;aMovieYear;[MOVIES]Title;aTitles;[MOVIES]Director;aDirectors; [MOVIES]Media;aMedias;[MOVIES]Sold_Tickets;aSoldTickets) ` Inicia o resto das colunas do list box para mostrar a informação ARRAY LONGINT(aNrActors;Size of array(amovieyear)) Utilizando o comando SQL EXECUTE IMMEDIATE: ARRAY LONGINT(aSoldTickets;0) ARRAY INTEGER(aMovieYear;0) ARRAY TEXT(aTitles;0) ARRAY TEXT(aDirectors;0) ARRAY TEXT(aMedias;0) C_TEXT($tQueryTxt) REDUCE SELECTION([MOVIES];0) $tquerytxt:="" $tquerytxt:=$tquerytxt+"select Year_of_Movie, Title, Director, Media, Sold_Tickets" $tquerytxt:=$tquerytxt+" FROM MOVIES" $tquerytxt:=$tquerytxt+" WHERE Year_of_Movie >= CAST('1960' AS INT)" $tquerytxt:=$tquerytxt+" INTO :amovieyear, :atitles, :adirectors, :amedias, :asoldtickets;" Begin SQL EXECUTE IMMEDIATE :$tquerytxt; End SQL ` Inicia o resto das colunas do list box para mostrar a informação ARRAY LONGINT(aNrActors;Size of array(amovieyear)) Para provar todos os exemplos anteriores, lance a base "4D SQL Code Samples" e vá até a janela principal. Depois escolha o modo de consulta e pressione o botão Using CAST.

14 Utilizar a cláusula ORDER BY Esta vez nos gostaria conseguir todas os filmes que foram lançados no ano 1960 ou mais recente, e para cada filme obter informação adicional, como o ano, título, diretor, os meios utilizados e boletos vendidos. O resultado deve ser organizado por ano. O código 4D inicial seria: ARRAY LONGINT(aNrActors;0) ARRAY LONGINT(aSoldTickets;0) ARRAY INTEGER(aMovieYear;0) ARRAY TEXT(aTitles;0) ARRAY TEXT(aDirectors;0) ARRAY TEXT(aMedias;0) C_LONGINT($MovieYear) REDUCE SELECTION([MOVIES];0) $MovieYear:=1960 QUERY([MOVIES];[MOVIES]Year_of_Movie>=$MovieYear) SELECTION TO ARRAY([MOVIES]Year_of_Movie;aMovieYear;[MOVIES]Title;aTitles;[MOVIES]Director;aDirectors; [MOVIES]Media;aMedias;[MOVIES]Sold_Tickets;aSoldTickets) SORT ARRAY(aMovieYear;aTitles;aDirectors;aMedias;>) Utilizando código SQL: ARRAY LONGINT(aNrActors;0) ARRAY LONGINT(aSoldTickets;0) ARRAY INTEGER(aMovieYear;0) ARRAY TEXT(aTitles;0) ARRAY TEXT(aDirectors;0) ARRAY TEXT(aMedias;0) C_LONGINT($MovieYear) REDUCE SELECTION([MOVIES];0) $MovieYear:=1960 Begin SQL SELECT Year_of_Movie, Title, Director, Media, Sold_Tickets FROM MOVIES WHERE Year_of_Movie >= :$MovieYear ORDER BY 1 INTO :amovieyear, :atitles, :adirectors, :amedias, :asoldtickets; End SQL Utilizando comandos SQL genéricos: C_TEXT($tQueryTxt) ARRAY LONGINT(aNrActors;0) ARRAY LONGINT(aSoldTickets;0) ARRAY INTEGER(aMovieYear;0) ARRAY TEXT(aTitles;0) ARRAY TEXT(aDirectors;0) ARRAY TEXT(aMedias;0) C_LONGINT($MovieYear) REDUCE SELECTION([MOVIES];0) $MovieYear:=1960 SQL LOGIN(SQL_INTERNAL;"";"") $tquerytxt:=""

15 $tquerytxt:=$tquerytxt+"select Year_of_Movie, Title, Director, Media, Sold_Tickets" $tquerytxt:=$tquerytxt+" FROM MOVIES" $tquerytxt:=$tquerytxt+" WHERE Year_of_Movie >= :$MovieYear" $tquerytxt:=$tquerytxt+" ORDER BY 1" SQL EXECUTE($tQueryTxt;aMovieYear;aTitles;aDirectors;aMedias;aSoldTickets) SQL LOAD RECORD(SQL all records) SQL LOGOUT Utilizando o comando QUERY BY SQL: ARRAY LONGINT(aNrActors;0) ARRAY LONGINT(aSoldTickets;0) ARRAY INTEGER(aMovieYear;0) ARRAY TEXT(aTitles;0) ARRAY TEXT(aDirectors;0) ARRAY TEXT(aMedias;0) C_LONGINT($MovieYear) REDUCE SELECTION([MOVIES];0) $MovieYear:=1960 QUERY BY SQL([MOVIES];"Year_of_Movie >= :$MovieYear") SELECTION TO ARRAY([MOVIES]Year_of_Movie;aMovieYear;[MOVIES]Title;aTitles;[MOVIES]Director;aDirectors; [MOVIES]Media;aMedias;[MOVIES]Sold_Tickets;aSoldTickets) SORT ARRAY(aMovieYear;aTitles;aDirectors;aMedias;>) Utilizando o comando SQL EXECUTE IMMEDIATE: ARRAY LONGINT(aNrActors;0) C_TEXT($tQueryTxt) ARRAY LONGINT(aSoldTickets;0) ARRAY INTEGER(aMovieYear;0) ARRAY TEXT(aTitles;0) ARRAY TEXT(aDirectors;0) ARRAY TEXT(aMedias;0) C_LONGINT($MovieYear) REDUCE SELECTION([MOVIES];0) $MovieYear:=1960 $tquerytxt:="" $tquerytxt:=$tquerytxt+"select Year_of_Movie, Title, Director, Media, Sold_Tickets" $tquerytxt:=$tquerytxt+" FROM MOVIES" $tquerytxt:=$tquerytxt+" WHERE Year_of_Movie >= :$MovieYear" $tquerytxt:=$tquerytxt+" ORDER BY 1" $tquerytxt:=$tquerytxt+" INTO :amovieyear, :atitles, :adirectors, :amedias, :asoldtickets;" Begin SQL EXECUTE IMMEDIATE :$tquerytxt; End SQL Para provar todos os exemplos anteriores, lance a base "4D SQL Code Samples" e vá até janela principal. A continuação, pode escolher o modo de pesquisa e pressionar o botão ORDER BY clause.

16 Utilizar a cláusula GROUP BY Queremos obter informação sobre o número anual total de entradas vendidas desde O resultado será ordenado por ano. O código 4D inicial seria: ` Using standard 4D code ARRAY INTEGER(aMovieYear;0) ARRAY LONGINT(aSoldTickets;0) C_LONGINT($MovieYear;$vCrtMovieYear;$i) REDUCE SELECTION([MOVIES];0) $MovieYear:=1979 QUERY([MOVIES];[MOVIES]Year_of_Movie>=$MovieYear) ORDER BY([MOVIES];[MOVIES]Year_of_Movie;>) $vcrtmovieyear:=0 $vind:=size of array(amovieyear) For($i;1;Records in selection([movies])) If([MOVIES]Year_of_Movie#$vCrtMovieYear) $vcrtmovieyear:=[movies]year_of_movie $vind:=$vind+1 INSERT IN ARRAY(aMovieYear;$vInd;1) amovieyear{$vind}:=$vcrtmovieyear INSERT IN ARRAY(aSoldTickets;$vInd;1) End if asoldtickets{$vind}:=asoldtickets{$vind}+[movies]sold_tickets NEXT RECORD([MOVIES]) End for ` Inicia o resto das colunas do list box para mostrar a informação ARRAY TEXT(aTitles;Size of array(amovieyear)) ARRAY TEXT(aDirectors;Size of array(amovieyear)) ARRAY TEXT(aMedias;Size of array(amovieyear)) ARRAY LONGINT(aNrActors;Size of array(amovieyear)) Utilizando código SQL: ` Using 4D SQL ARRAY INTEGER(aMovieYear;0) ARRAY LONGINT(aSoldTickets;0) C_LONGINT($MovieYear) REDUCE SELECTION([MOVIES];0) $MovieYear:=1979 Begin SQL SELECT Year_of_Movie, SUM(Sold_Tickets) FROM MOVIES WHERE Year_of_Movie >= :$MovieYear GROUP BY Year_of_Movie ORDER BY 1 INTO :amovieyear, :asoldtickets; End SQL ` Inicia o resto das colunas do list box para mostrar a informação ARRAY TEXT(aTitles;Size of array(amovieyear)) ARRAY TEXT(aDirectors;Size of array(amovieyear)) ARRAY TEXT(aMedias;Size of array(amovieyear)) ARRAY LONGINT(aNrActors;Size of array(amovieyear)) Utilizando comandos SQL genéricos:

17 ` Using ODBC commands C_TEXT($tQueryTxt) ARRAY LONGINT(aSoldTickets;0) ARRAY INTEGER(aMovieYear;0) C_LONGINT($MovieYear) REDUCE SELECTION([MOVIES];0) $MovieYear:=1979 SQL LOGIN(SQL_INTERNAL;"";"") $tquerytxt:="" $tquerytxt:=$tquerytxt+"select Year_of_Movie, SUM(Sold_Tickets)" $tquerytxt:=$tquerytxt+" FROM MOVIES" $tquerytxt:=$tquerytxt+" WHERE Year_of_Movie >= :$MovieYear" $tquerytxt:=$tquerytxt+" GROUP BY Year_of_Movie" $tquerytxt:=$tquerytxt+" ORDER BY 1" SQL EXECUTE($tQueryTxt;aMovieYear;aSoldTickets) SQL LOAD RECORD(SQL all records) SQL LOGOUT ` Inicia o resto das colunas do list box para mostrar a informação ARRAY TEXT(aTitles;Size of array(amovieyear)) ARRAY TEXT(aDirectors;Size of array(amovieyear)) ARRAY TEXT(aMedias;Size of array(amovieyear)) ARRAY LONGINT(aNrActors;Size of array(amovieyear)) Utilizando o comando QUERY BY SQL: ` Using QUERY BY SQL ARRAY LONGINT(aSoldTickets;0) ARRAY INTEGER(aMovieYear;0) C_LONGINT($MovieYear) REDUCE SELECTION([MOVIES];0) $MovieYear:=1979 QUERY BY SQL([MOVIES];"Year_of_Movie >= :$MovieYear") ORDER BY([MOVIES];[MOVIES]Year_of_Movie;>) $vcrtmovieyear:=0 $vind:=size of array(amovieyear) For($i;1;Records in selection([movies])) If([MOVIES]Year_of_Movie#$vCrtMovieYear) $vcrtmovieyear:=[movies]year_of_movie $vind:=$vind+1 INSERT IN ARRAY(aMovieYear;$vInd;1) amovieyear{$vind}:=$vcrtmovieyear INSERT IN ARRAY(aSoldTickets;$vInd;1) End if asoldtickets{$vind}:=asoldtickets{$vind}+[movies]sold_tickets NEXT RECORD([MOVIES]) End for ` Inicia o resto das colunas do list box para mostrar a informação ARRAY TEXT(aTitles;Size of array(amovieyear)) ARRAY TEXT(aDirectors;Size of array(amovieyear)) ARRAY TEXT(aMedias;Size of array(amovieyear)) ARRAY LONGINT(aNrActors;Size of array(amovieyear)) Utilizando o comando SQL EXECUTE IMMEDIATE: ` Using dynamic SQL by EXECUTE IMMEDIATE C_TEXT($tQueryTxt) ARRAY LONGINT(aSoldTickets;0) ARRAY INTEGER(aMovieYear;0) C_LONGINT($MovieYear) $MovieYear:=1979 $tquerytxt:=""

18 $tquerytxt:=$tquerytxt+"select Year_of_Movie, SUM(Sold_Tickets)" $tquerytxt:=$tquerytxt+" FROM MOVIES" $tquerytxt:=$tquerytxt+" WHERE Year_of_Movie >= :$MovieYear" $tquerytxt:=$tquerytxt+" GROUP BY Year_of_Movie" $tquerytxt:=$tquerytxt+" ORDER BY 1" $tquerytxt:=$tquerytxt+" INTO :amovieyear, :asoldtickets;" Begin SQL EXECUTE IMMEDIATE :$tquerytxt; End SQL ` Inicia o resto das colunas do list box para mostrar a informação ARRAY TEXT(aTitles;Size of array(amovieyear)) ARRAY TEXT(aDirectors;Size of array(amovieyear)) ARRAY TEXT(aMedias;Size of array(amovieyear)) ARRAY LONGINT(aNrActors;Size of array(amovieyear)) Para provar todos os exemplos anteriores, lance a base "4D SQL Code Samples" e vá até a janela principal. A continuação, pode escolher o modo de pesquisa e pressionar o botão GROUP BY clause.

19 Utilizar funçõs estadísticas As funções estatísticas permitem realizar cálculos em uma serie de valores. SQL contém numerosas funções de agregação MIN, MAX, AVG, SUM, etc. Utilizando as funções de agregação, queremos obter informação sobre o número de boletos vendidos cada ano. O resultado será ordenado por ano. Para fazer isto, devemos realizar a suma de todos os boletos vendidos para cada filme e depois ordenar por ano. O código 4D inicial seria: C_LONGINT($vMin;$vMax;$vSum) C_REAL($vAverage) C_TEXT($AlertTxt) REDUCE SELECTION([MOVIES];0) $vmin:=0 $vmax:=0 $vaverage:=0 $vsum:=0 ALL RECORDS([MOVIES]) $vmin:=min([movies]sold_tickets) $vmax:=max([movies]sold_tickets) $vaverage:=average([movies]sold_tickets) $vsum:=sum([movies]sold_tickets) `$AlertTxt:="" `$AlertTxt:=$AlertTxt+"Minimum tickets sold: "+Chaine($vMin)+Caractere(13) `$AlertTxt:=$AlertTxt+"Maximum tickets sold: "+Chaine($vMax)+Caractere(13) `$AlertTxt:=$AlertTxt+"Average tickets sold: "+Chaine($vAverage)+Caractere(13) `$AlertTxt:=$AlertTxt+"Total tickets sold: "+Chaine($vSum)+Caractere(13) Utilizando código SQL: C_LONGINT($vMin;$vMax;$vSum) C_REAL($vAverage) C_TEXT($AlertTxt) $vmin:=0 $vmax:=0 $vaverage:=0 $vsum:=0 Begin SQL SELECT MIN(Sold_Tickets), MAX(Sold_Tickets), AVG(Sold_Tickets), SUM(Sold_Tickets) FROM MOVIES INTO :$vmin, :$vmax, :$vaverage, :$vsum; End SQL `$AlertTxt:="" `$AlertTxt:=$AlertTxt+"Minimum tickets sold: "+Chaine($vMin)+Caractere(13) `$AlertTxt:=$AlertTxt+"Maximum tickets sold: "+Chaine($vMax)+Caractere(13) `$AlertTxt:=$AlertTxt+"Average tickets sold: "+Chaine($vAverage)+Caractere(13) `$AlertTxt:=$AlertTxt+"Total tickets sold: "+Chaine($vSum)+Caractere(13) `ALERT($AlertTxt) Utilizando comandos SQL genéricos: C_LONGINT($vMin;$vMax;$vSum) C_REAL($vAverage)

20 C_TEXT($tQueryTxt) C_TEXT($AlertTxt) $vmin:=0 $vmax:=0 $vaverage:=0 $vsum:=0 SQL LOGIN(SQL_INTERNAL;"";"") $tquerytxt:="" $tquerytxt:=$tquerytxt+"select MIN(Sold_Tickets), MAX(Sold_Tickets), AVG(Sold_Tickets), SUM(Sold_Tickets)" $tquerytxt:=$tquerytxt+" FROM MOVIES" SQL EXECUTE($tQueryTxt;$vMin;$vMax;$vAverage;$vSum) SQL LOAD RECORD(SQL all records) SQL LOGOUT $AlertTxt:="" `$AlertTxt:=$AlertTxt+"Minimum tickets sold: "+Chaine($vMin)+Caractere(13) `$AlertTxt:=$AlertTxt+"Maximum tickets sold: "+Chaine($vMax)+Caractere(13) `$AlertTxt:=$AlertTxt+"Average tickets sold: "+Chaine($vAverage)+Caractere(13) `$AlertTxt:=$AlertTxt+"Total tickets sold: "+Chaine($vSum)+Caractere(13) `ALERT($AlertTxt) Utilizando o comando EXECUTE IMMEDIATE: C_LONGINT($vMin;$vMax;$vSum) C_REAL($vAverage) C_TEXT($tQueryTxt) C_TEXT($AlertTxt) $vmin:=0 $vmax:=0 $vaverage:=0 $vsum:=0 $tquerytxt:="" $tquerytxt:=$tquerytxt+"select MIN(Sold_Tickets), MAX(Sold_Tickets), AVG(Sold_Tickets), SUM(Sold_Tickets)" $tquerytxt:=$tquerytxt+" FROM MOVIES" $tquerytxt:=$tquerytxt+" INTO :$vmin, :$vmax, :$vaverage, :$vsum;" Begin SQL EXECUTE IMMEDIATE :$tquerytxt; End SQL `$AlertTxt:="" `$AlertTxt:=$AlertTxt+"Minimum tickets sold: "+Chaine($vMin)+Caractere(13) `$AlertTxt:=$AlertTxt+"Maximum tickets sold: "+Chaine($vMax)+Caractere(13) `$AlertTxt:=$AlertTxt+"Average tickets sold: "+Chaine($vAverage)+Caractere(13) `$AlertTxt:=$AlertTxt+"Total tickets sold: "+Chaine($vSum)+Caractere(13) `ALERT($AlertTxt) Para provar todos os exemplos anteriores, lance a base "4D SQL Code Samples" e vá até a janela principal. A continuação, pode escolher o modo de pesquisa e pressionar o botão Using Aggregate functions.

21 Utilizar a cláusula HAVING Agora queremos obter o número total de entradas vendidas por ano a partir de 1979, sem incluir os filmes com mais de 10,000,000 boletos vendidos. O resultado será ordenado por ano. Para fazer isto, devemos somar o total de boletos vendidos para cada filmes desde 1979, eliminar as entradas cujo total de boletos vendidos seja maior a 10,000,000, e depois ordenar o resultado por ano. O código 4D inicial seria: ARRAY INTEGER(aMovieYear;0) ARRAY LONGINT(aSoldTickets;0) C_LONGINT($MovieYear;$vCrtMovieYear;$i;$MinSoldTickets;$vInd) REDUCE SELECTION([MOVIES];0) $MovieYear:=1979 $MinSoldTickets:= QUERY([MOVIES];[MOVIES]Year_of_Movie>=$MovieYear) ORDER BY([MOVIES];[MOVIES]Year_of_Movie;>) $vcrtmovieyear:=0 $vind:=size of array(amovieyear) For($i;1;Records in selection([movies])) If([MOVIES]Year_of_Movie#$vCrtMovieYear) $vcrtmovieyear:=[movies]year_of_movie If(aSoldTickets{$vInd}<$MinSoldTickets) $vind:=$vind+1 INSERT IN ARRAY(aMovieYear;$vInd;1) amovieyear{$vind}:=$vcrtmovieyear INSERT IN ARRAY(aSoldTickets;$vInd;1) Else asoldtickets{$vind}:=0 End if End if asoldtickets{$vind}:=asoldtickets{$vind}+[movies]sold_tickets NEXT RECORD([MOVIES]) End for If(aSoldTickets{$vInd}>=$MinSoldTickets) DELETE FROM ARRAY(aSoldTickets;$vInd;1) DELETE FROM ARRAY(aMovieYear;$vInd;1) End if ` Inicia o resto das colunas para mostrar a informação ARRAY TEXT(aTitles;Size of array(amovieyear)) ARRAY TEXT(aDirectors;Size of array(amovieyear)) ARRAY TEXT(aMedias;Size of array(amovieyear)) ARRAY LONGINT(aNrActors;Size of array(amovieyear)) Utilizando código SQL: ARRAY INTEGER(aMovieYear;0) ARRAY LONGINT(aSoldTickets;0) C_LONGINT($MovieYear;$MinSoldTickets) $MovieYear:=1979 $MinSoldTickets:= Begin SQL SELECT Year_of_Movie, SUM(Sold_Tickets) FROM MOVIES WHERE Year_of_Movie >= :$MovieYear GROUP BY Year_of_Movie HAVING SUM(Sold_Tickets) < :$MinSoldTickets ORDER BY 1

22 INTO :amovieyear, :asoldtickets; End SQL ` Inicia o resto das colunas para mostrar a informação ARRAY TEXT(aTitles;Size of array(amovieyear)) ARRAY TEXT(aDirectors;Size of array(amovieyear)) ARRAY TEXT(aMedias;Size of array(amovieyear)) ARRAY LONGINT(aNrActors;Size of array(amovieyear)) Utilizando comandos SQL genéricos: C_TEXT($tQueryTxt) ARRAY INTEGER(aMovieYear;0) ARRAY LONGINT(aSoldTickets;0) C_LONGINT($MovieYear;$MinSoldTickets) $MovieYear:=1979 $MinSoldTickets:= SQL LOGIN(SQL_INTERNAL;"";"") $tquerytxt:="" $tquerytxt:=$tquerytxt+"select Year_of_Movie, SUM(Sold_Tickets)" $tquerytxt:=$tquerytxt+" FROM MOVIES" $tquerytxt:=$tquerytxt+" WHERE Year_of_Movie >= :$MovieYear" $tquerytxt:=$tquerytxt+" GROUP BY Year_of_Movie" $tquerytxt:=$tquerytxt+" HAVING SUM(Sold_Tickets) < :$MinSoldTickets" $tquerytxt:=$tquerytxt+" ORDER BY 1" SQL EXECUTE($tQueryTxt;aMovieYear;aSoldTickets) SQL LOAD RECORD(SQL all records) SQL LOGOUT ` Inicia o resto das colunas para mostrar a informação ARRAY TEXT(aTitles;Size of array(amovieyear)) ARRAY TEXT(aDirectors;Size of array(amovieyear)) ARRAY TEXT(aMedias;Size of array(amovieyear)) ARRAY LONGINT(aNrActors;Size of array(amovieyear)) Utilizando o comando QUERY BY SQL: C_TEXT($tQueryTxt) ARRAY INTEGER(aMovieYear;0) ARRAY LONGINT(aSoldTickets;0) C_LONGINT($MovieYear;$MinSoldTickets;$vCrtMovieYear;$vInd;$i) REDUCE SELECTION([MOVIES];0) $MovieYear:=1979 $MinSoldTickets:= QUERY BY SQL([MOVIES];"Year_of_Movie >= :$MovieYear") ORDER BY([MOVIES];[MOVIES]Year_of_Movie;>) $vcrtmovieyear:=0 $vind:=size of array(amovieyear) For($i;1;Records in selection([movies])) If([MOVIES]Year_of_Movie#$vCrtMovieYear) $vcrtmovieyear:=[movies]year_of_movie If(aSoldTickets{$vInd}<$MinSoldTickets) $vind:=$vind+1 INSERT IN ARRAY(aMovieYear;$vInd;1) amovieyear{$vind}:=$vcrtmovieyear INSERT IN ARRAY(aSoldTickets;$vInd;1) Else asoldtickets{$vind}:=0 End if End if asoldtickets{$vind}:=asoldtickets{$vind}+[movies]sold_tickets NEXT RECORD([MOVIES]) End for If(aSoldTickets{$vInd}>=$MinSoldTickets)

23 DELETE FROM ARRAY(aSoldTickets;$vInd;1) DELETE FROM ARRAY(aMovieYear;$vInd;1) End if ` Inicia o resto das colunas para mostrar a informação ARRAY TEXT(aTitles;Size of array(amovieyear)) ARRAY TEXT(aDirectors;Size of array(amovieyear)) ARRAY TEXT(aMedias;Size of array(amovieyear)) ARRAY LONGINT(aNrActors;Size of array(amovieyear)) Utilizando o comando SQL EXECUTE IMMEDIATE: C_TEXT($tQueryTxt) ARRAY INTEGER(aMovieYear;0) ARRAY LONGINT(aSoldTickets;0) C_LONGINT($MovieYear;$MinSoldTickets) $MovieYear:=1979 $MinSoldTickets:= $tquerytxt:="" $tquerytxt:=$tquerytxt+"select Year_of_Movie, SUM(Sold_Tickets)" $tquerytxt:=$tquerytxt+" FROM MOVIES" $tquerytxt:=$tquerytxt+" WHERE Year_of_Movie >= :$MovieYear" $tquerytxt:=$tquerytxt+" GROUP BY Year_of_Movie" $tquerytxt:=$tquerytxt+" HAVING SUM(Sold_Tickets) < :$MinSoldTickets" $tquerytxt:=$tquerytxt+" ORDER BY 1" $tquerytxt:=$tquerytxt+" INTO :amovieyear, :asoldtickets;" Begin SQL EXECUTE IMMEDIATE :$tquerytxt; End SQL ` Inicia o resto das colunas para mostrar a informação ARRAY TEXT(aTitles;Size of array(amovieyear)) ARRAY TEXT(aDirectors;Size of array(amovieyear)) ARRAY TEXT(aMedias;Size of array(amovieyear)) ARRAY LONGINT(aNrActors;Size of array(amovieyear)) Para provar todos os exemplos anteriores, lance a base "4D SQL Code Samples" e vá até a janela principal. A continuação, pode escolher o modo de pesquisa e pressionar o botão HAVING clause.

24 Chamar os métodos 4D desde o código SQL Agora queremos realizar pesquisas relativas aos atores de cada filme: especificamente, estamos interessados em encontrar todas os filmes com pelo menos 7 atores. O resultado será ordenado por ano. Para fazer isto, utilizamos uma função 4D (Find_Nr_Of_Actors) que recebe o ID do filme e devolve o número de atores do filme: `(F) Find_Nr_Of_Actors C_LONGINT($0;$1;$vMovie_ID) $vmovie_id:=$1 QUERY([MOVIE_ACTOR];[MOVIE_ACTOR]Movie_ID=$vMovie_ID) $0:=Records in selection([movie_actor]) O código 4D inicial seria: ARRAY LONGINT(aSoldTickets;0) ARRAY INTEGER(aMovieYear;0) ARRAY LONGINT(aNrActors;0) ARRAY TEXT(aTitles;0) ARRAY TEXT(aDirectors;0) ARRAY TEXT(aMedias;0) C_LONGINT($NrOfActors;$i;$vInd) $vind:=0 $NrOfActors:=7 ALL RECORDS([MOVIES]) For($i;1;Records in selection([movies])) $vcrtactors:=find_nr_of_actors([movies]id) If($vCrtActors>=$NrOfActors) $vind:=$vind+1 INSERT IN ARRAY(aMovieYear;$vInd;1) amovieyear{$vind}:=[movies]year_of_movie INSERT IN ARRAY(aTitles;$vInd;1) atitles{$vind}:=[movies]title INSERT IN ARRAY(aDirectors;$vInd;1) adirectors{$vind}:=[movies]director INSERT IN ARRAY(aMedias;$vInd;1) amedias{$vind}:=[movies]media INSERT IN ARRAY(aSoldTickets;$vInd;1) asoldtickets{$vind}:=[movies]sold_tickets INSERT IN ARRAY(aNrActors;$vInd;1) anractors{$vind}:=$vcrtactors End if NEXT RECORD([MOVIES]) End for SORT ARRAY(aMovieYear;aTitles;aDirectors;aMedias;aSoldTickets;aNrActors;>) Utilizando código SQL: ARRAY LONGINT(aSoldTickets;0) ARRAY INTEGER(aMovieYear;0) ARRAY LONGINT(aNrActors;0) ARRAY TEXT(aTitles;0) ARRAY TEXT(aDirectors;0) ARRAY TEXT(aMedias;0) C_LONGINT($NrOfActors;$i;$vInd) $vind:=0 $NrOfActors:=7

25 Begin SQL SELECT Year_of_Movie, Title, Director, Media, Sold_Tickets, {fn Find_Nr_Of_Actors(ID) AS NUMERIC} FROM MOVIES WHERE {fn Find_Nr_Of_Actors(ID) AS NUMERIC} >= :$NrOfActors ORDER BY 1 INTO :amovieyear, :atitles, :adirectors, :amedias, :asoldtickets, :anractors; End SQL Pode ver que podemos chamar a uma função 4D dentro do código SQL utilizando a sintaxes: {fn 4DFunctionName AS 4DFunctionResultType} Utilizando comandos SQL genéricos: ARRAY LONGINT(aSoldTickets;0) ARRAY INTEGER(aMovieYear;0) ARRAY LONGINT(aNrActors;0) ARRAY TEXT(aTitles;0) ARRAY TEXT(aDirectors;0) ARRAY TEXT(aMedias;0) C_LONGINT($NrOfActors;$i;$vInd) C_TEXT($tQueryTxt) $vind:=0 $NrOfActors:=7 SQL LOGIN(SQL_INTERNAL;"";"") $tquerytxt:="" $tquerytxt:=$tquerytxt+"select Year_of_Movie, Title, Director, Media, Sold_Tickets, {fn Find_Nr_Of_Actors(ID) AS NUMERIC}" $tquerytxt:=$tquerytxt+" FROM MOVIES" $tquerytxt:=$tquerytxt+" WHERE {fn Find_Nr_Of_Actors(ID) AS NUMERIC} >= :$NrOfActors" $tquerytxt:=$tquerytxt+" ORDER BY 1" SQL EXECUTE($tQueryTxt;aMovieYear;aTitles;aDirectors;aMedias;aSoldTickets;aNrActors) SQL LOAD RECORD(SQL all records) SQL LOGOUT Utilizando o comando QUERY BY SQL: ARRAY LONGINT(aSoldTickets;0) ARRAY INTEGER(aMovieYear;0) ARRAY LONGINT(aNrActors;0) ARRAY TEXT(aTitles;0) ARRAY TEXT(aDirectors;0) ARRAY TEXT(aMedias;0) C_LONGINT($NrOfActors;$i;$vInd) $vind:=0 $NrOfActors:=7 QUERY BY SQL([MOVIES];"{fn Find_Nr_Of_Actors(ID) AS NUMERIC} >= :$NrOfActors") For($i;1;Records in selection([movies])) $vind:=$vind+1 INSERT IN ARRAY(aMovieYear;$vInd;1) amovieyear{$vind}:=[movies]year_of_movie INSERT IN ARRAY(aTitles;$vInd;1) atitles{$vind}:=[movies]title INSERT IN ARRAY(aDirectors;$vInd;1) adirectors{$vind}:=[movies]director INSERT IN ARRAY(aMedias;$vInd;1) amedias{$vind}:=[movies]media INSERT IN ARRAY(aSoldTickets;$vInd;1) asoldtickets{$vind}:=[movies]sold_tickets

26 INSERT IN ARRAY(aNrActors;$vInd;1) anractors{$vind}:=find_nr_of_actors([movies]id) NEXT RECORD([MOVIES]) End for SORT ARRAY(aMovieYear;aTitles;aDirectors;aMedias;aSoldTickets;aNrActors;>) Utilizando o comando SQL EXECUTE IMMEDIATE: ARRAY LONGINT(aSoldTickets;0) ARRAY INTEGER(aMovieYear;0) ARRAY LONGINT(aNrActors;0) ARRAY TEXT(aTitles;0) ARRAY TEXT(aDirectors;0) ARRAY TEXT(aMedias;0) C_LONGINT($NrOfActors;$i;$vInd) C_TEXT($tQueryTxt) $vind:=0 $NrOfActors:=7 $tquerytxt:="" $tquerytxt:=$tquerytxt+"select Year_of_Movie, Title, Director, Media, Sold_Tickets, {fn Find_Nr_Of_Actors(ID) AS NUMERIC}" $tquerytxt:=$tquerytxt+" FROM MOVIES" $tquerytxt:=$tquerytxt+" WHERE {fn Find_Nr_Of_Actors(ID) AS NUMERIC} >= :$NrOfActors" $tquerytxt:=$tquerytxt+" ORDER BY 1" $tquerytxt:=$tquerytxt+" INTO :amovieyear, :atitles, :adirectors, :amedias, :asoldtickets,"+" :anractors;" Begin SQL EXECUTE IMMEDIATE :$tquerytxt; End SQL Para provar todos os exemplos anteriores, lance a base "4D SQL Code Samples" e vá até a janela principal. A continuação, pode escolher o modo de pesquisa e pressionar o botão Calling 4D methods.

27 Joins Agora queremos conhecer a cidade de nascimento de cada ator. A lista de atores está na tabela ACTORS e a lista de cidades na tabela CITIES. Para executar esta pesquisa necessitamos unir as duas tabelas: ACTORS e CITIES. O código 4D inicial seria: ARRAY LONGINT(aSoldTickets;0) ARRAY TEXT(aTitles;0) ARRAY TEXT(aDirectors;0) C_LONGINT($i;$vInd) $vind:=0 ALL RECORDS([ACTORS]) For($i;1;Records in selection([actors])) $vind:=$vind+1 INSERT IN ARRAY(aTitles;$vInd;1) atitles{$vind}:=[actors]firstname+" "+[ACTORS]LastName RELATE ONE([ACTORS]Birth_City_ID) INSERT IN ARRAY(aDirectors;$vInd;1) adirectors{$vind}:=[cities]city_name NEXT RECORD([ACTORS]) End for ` Inicia o resto das colunas do list box para mostrar a informação ARRAY INTEGER(aMovieYear;Size of array(atitles)) ARRAY TEXT(aMedias;Size of array(atitles)) ARRAY LONGINT(aSoldTickets;Size of array(atitles)) ARRAY LONGINT(aNrActors;Size of array(atitles)) MULTI SORT ARRAY(aDirectors;>;aTitles;>;aMovieYear;aMedias;aSoldTickets;aNrActors) Utilizando código SQL: ARRAY TEXT(aTitles;0) ARRAY TEXT(aDirectors;0) Begin SQL SELECT CONCAT(CONCAT(ACTORS.FirstName,' '),ACTORS.LastName), CITIES.City_Name FROM ACTORS, CITIES WHERE ACTORS.Birth_City_ID=CITIES.City_ID ORDER BY 2,1 INTO :atitles, :adirectors; End SQL ` Inicia o resto das colunas do list box para mostrar a informação ARRAY INTEGER(aMovieYear;Size of array(atitles)) ARRAY TEXT(aMedias;Size of array(atitles)) ARRAY LONGINT(aSoldTickets;Size of array(atitles)) ARRAY LONGINT(aNrActors;Size of array(atitles)) Utilizando comandos SQL genéricos: ARRAY TEXT(aTitles;0) ARRAY TEXT(aDirectors;0) C_TEXT($tQueryTxt) SQL LOGIN(SQL_INTERNAL;"";"") $tquerytxt:="" $tquerytxt:=$tquerytxt+"select CONCAT(CONCAT(ACTORS.FirstName,' '),ACTORS.LastName), CITIES.City_Name"

28 $tquerytxt:=$tquerytxt+" FROM ACTORS, CITIES" $tquerytxt:=$tquerytxt+" WHERE ACTORS.Birth_City_ID=CITIES.City_ID" $tquerytxt:=$tquerytxt+" ORDER BY 2,1" SQL EXECUTE($tQueryTxt;aTitles;aDirectors) SQL LOAD RECORD(SQL all records) SQL LOGOUT ` Inicia o resto das colunas do list box para mostrar a informação ARRAY INTEGER(aMovieYear;Size of array(atitles)) ARRAY TEXT(aMedias;Size of array(atitles)) ARRAY LONGINT(aSoldTickets;Size of array(atitles)) ARRAY LONGINT(aNrActors;Size of array(atitles)) Utilizando o comando QUERY BY SQL, não podemos realizar a pesquisa anterior porque não é possível passar mais de uma tabela como primeiro parâmetro. Utilizando o comando SQL EXECUTE IMMEDIATE: ARRAY TEXT(aTitles;0) ARRAY TEXT(aDirectors;0) C_TEXT($tQueryTxt) $tquerytxt:="" $tquerytxt:=$tquerytxt+"select CONCAT(CONCAT(ACTORS.FirstName,' '),ACTORS.LastName), CITIES.City_Name" $tquerytxt:=$tquerytxt+" FROM ACTORS, CITIES" $tquerytxt:=$tquerytxt+" WHERE ACTORS.Birth_City_ID=CITIES.City_ID" $tquerytxt:=$tquerytxt+" ORDER BY 2,1" $tquerytxt:=$tquerytxt+" INTO :atitles, :adirectors" Begin SQL EXECUTE IMMEDIATE :$tquerytxt; End SQL ` Inicia o resto das colunas do list box para mostrar a informação ARRAY INTEGER(aMovieYear;Size of array(atitles)) ARRAY TEXT(aMedias;Size of array(atitles)) ARRAY LONGINT(aSoldTickets;Size of array(atitles)) ARRAY LONGINT(aNrActors;Size of array(atitles)) Para provar todos os exemplos anteriores, lance a base "4D SQL Code Samples" e vá até a janela principal. A continuação, pode escolher o modo de pesquisa e pressionar o botão Joins.

29 Utilizar Alias Se uma pesquisa SQL é muito complexa e contém nomes grandes que dificultam a leitura, é possível utilizar alias para melhorar sua legibilidade. Este é o exemplo anterior utilizando dois alias: Act para a tabela ACTORS e Cit para a tabela CITIES. O código 4D inicial seria: ARRAY LONGINT(aSoldTickets;0) ARRAY TEXT(aTitles;0) ARRAY TEXT(aDirectors;0) C_LONGINT($i;$vInd) $vind:=0 ALL RECORDS([ACTORS]) For($i;1;Records in selection([actors])) $vind:=$vind+1 INSERT IN ARRAY(aTitles;$vInd;1) atitles{$vind}:=[actors]firstname+" "+[ACTORS]LastName RELATE ONE([ACTORS]Birth_City_ID) INSERT IN ARRAY(aDirectors;$vInd;1) adirectors{$vind}:=[cities]city_name NEXT RECORD([ACTORS]) End for ` Inicia o resto das colunas do list box para mostrar a informação ARRAY INTEGER(aMovieYear;Size of array(atitles)) ARRAY TEXT(aMedias;Size of array(atitles)) ARRAY LONGINT(aSoldTickets;Size of array(atitles)) ARRAY LONGINT(aNrActors;Size of array(atitles)) MULTI SORT ARRAY(aDirectors;>;aTitles;>;aMovieYear;aMedias;aSoldTickets;aNrActors) Utilizando código SQL: ARRAY TEXT(aTitles;0) ARRAY TEXT(aDirectors;0) Begin SQL SELECT CONCAT(CONCAT(ACTORS.FirstName,' '),ACTORS.LastName), CITIES.City_Name FROM ACTORS AS 'Act', CITIES AS 'Cit' WHERE Act.Birth_City_ID=Cit.City_ID ORDER BY 2,1 INTO :atitles, :adirectors; End SQL ` Inicia o resto das colunas do list box para mostrar a informação ARRAY INTEGER(aMovieYear;Size of array(atitles)) ARRAY TEXT(aMedias;Size of array(atitles)) ARRAY LONGINT(aSoldTickets;Size of array(atitles)) ARRAY LONGINT(aNrActors;Size of array(atitles)) Utilizando comandos SQL genéricos: ARRAY TEXT(aTitles;0) ARRAY TEXT(aDirectors;0) C_TEXT($tQueryTxt) SQL LOGIN(SQL_INTERNAL;"";"") $tquerytxt:="" $tquerytxt:=$tquerytxt+"select CONCAT(CONCAT(ACTORS.FirstName,' '),ACTORS.LastName),

30 CITIES.City_Name" $tquerytxt:=$tquerytxt+" FROM ACTORS AS 'Act', CITIES AS 'Cit'" $tquerytxt:=$tquerytxt+" WHERE Act.Birth_City_ID=Cit.City_ID" $tquerytxt:=$tquerytxt+" ORDER BY 2,1" SQL EXECUTE($tQueryTxt;aTitles;aDirectors) SQL LOAD RECORD(SQL all records) SQL LOGOUT ` Inicia o resto das colunas do list box para mostrar a informação ARRAY INTEGER(aMovieYear;Size of array(atitles)) ARRAY TEXT(aMedias;Size of array(atitles)) ARRAY LONGINT(aSoldTickets;Size of array(atitles)) ARRAY LONGINT(aNrActors;Size of array(atitles)) Utilizando o comando QUERY BY SQL, não podemos realizar a pesquisa anterior porque não é possível passar mais de uma tabela como primeiro parâmetro. Utilizando o comando SQL EXECUTE IMMEDIATE: ARRAY TEXT(aTitles;0) ARRAY TEXT(aDirectors;0) C_TEXT($tQueryTxt) $tquerytxt:="" $tquerytxt:=$tquerytxt+"select CONCAT(CONCAT(ACTORS.FirstName,' '),ACTORS.LastName), CITIES.City_Name" $tquerytxt:=$tquerytxt+" FROM ACTORS AS 'Act', CITIES AS 'Cit'" $tquerytxt:=$tquerytxt+" WHERE Act.Birth_City_ID=Cit.City_ID" $tquerytxt:=$tquerytxt+" ORDER BY 2,1" $tquerytxt:=$tquerytxt+" INTO :atitles, :adirectors" Begin SQL EXECUTE IMMEDIATE :$tquerytxt; End SQL ARRAY INTEGER(aMovieYear;Size of array(atitles)) ARRAY TEXT(aMedias;Size of array(atitles)) ARRAY LONGINT(aSoldTickets;Size of array(atitles)) ARRAY LONGINT(aNrActors;Size of array(atitles)) Para provar todos os exemplos anteriores, lance a base "4D SQL Code Samples" e vá até a janela principal. Escolha o modo de consulta e pressione o botão Using Aliases.

31 Subconsultas Agora queremos obter uma informação estatística sobre os ingressos vendidos: quais são os filmes cujos boletos vendidos são superiores a média de ingressos vendidos para todas os filmes. Para executar esta pesquisa em SQL, utilizaremos uma pesquisa em uma pesquisa, em outras palavras uma subconsulta. O código 4D inicial seria: ARRAY LONGINT(aSoldTickets;0) ARRAY TEXT(aTitles;0) C_LONGINT($i;$vInd;$vAvgSoldTickets) $vind:=0 ALL RECORDS([MOVIES]) $vavgsoldtickets:=average([movies]sold_tickets) For($i;1;Records in selection([movies])) If([MOVIES]Sold_Tickets>$vAvgSoldTickets) $vind:=$vind+1 INSERT IN ARRAY(aTitles;$vInd;1) atitles{$vind}:=[movies]title INSERT IN ARRAY(aSoldTickets;$vInd;1) asoldtickets{$vind}:=[movies]sold_tickets End if NEXT RECORD([MOVIES]) End for ` Inicia o resto das colunas do list box com o propósito de visualizar a informação ARRAY INTEGER(aMovieYear;Size of array(atitles)) ARRAY TEXT(aDirectors;Size of array(atitles)) ARRAY TEXT(aMedias;Size of array(atitles)) ARRAY LONGINT(aNrActors;Size of array(atitles)) SORT ARRAY(aTitles;aDirectors;aMovieYear;aMedias;aSoldTickets;aNrActors;>) Utilizando código SQL: ARRAY LONGINT(aSoldTickets;0) ARRAY TEXT(aTitles;0) Begin SQL SELECT Title, Sold_Tickets FROM MOVIES WHERE Sold_Tickets > (SELECT AVG(Sold_Tickets) FROM MOVIES) ORDER BY 1 INTO :atitles, :asoldtickets; End SQL ` Inicia o resto das colunas do list box com o propósito de visualizar a informação ARRAY INTEGER(aMovieYear;Size of array(atitles)) ARRAY TEXT(aDirectors;Size of array(atitles)) ARRAY TEXT(aMedias;Size of array(atitles)) ARRAY LONGINT(aNrActors;Size of array(atitles)) SORT ARRAY(aTitles;aDirectors;aMovieYear;aMedias;aSoldTickets;aNrActors;>) Utilizando comandos SQL genéricos: ARRAY LONGINT(aSoldTickets;0) ARRAY TEXT(aTitles;0) C_TEXT($tQueryTxt) SQL LOGIN(SQL_INTERNAL;"";"") $tquerytxt:=""

32 $tquerytxt:=$tquerytxt+"select Title, Sold_Tickets" $tquerytxt:=$tquerytxt+" FROM MOVIES" $tquerytxt:=$tquerytxt+" WHERE Sold_Tickets > (SELECT AVG(Sold_Tickets) FROM MOVIES)" $tquerytxt:=$tquerytxt+" ORDER BY 1" SQL EXECUTE($tQueryTxt;aTitles;aSoldTickets) SQL LOAD RECORD(SQL all records) SQL LOGOUT ` Inicia o resto das colunas do list box com o propósito de visualizar a informação ARRAY INTEGER(aMovieYear;Size of array(atitles)) ARRAY TEXT(aDirectors;Size of array(atitles)) ARRAY TEXT(aMedias;Size of array(atitles)) ARRAY LONGINT(aNrActors;Size of array(atitles)) SORT ARRAY(aTitles;aDirectors;aMovieYear;aMedias;aSoldTickets;aNrActors;>) Utilizando o comando QUERY BY SQL: ARRAY LONGINT(aSoldTickets;0) ARRAY TEXT(aTitles;0) QUERY BY SQL([MOVIES];"Sold_Tickets > (SELECT AVG(Sold_Tickets) FROM MOVIES)") ORDER BY([MOVIES];[MOVIES]Title;>) SELECTION TO ARRAY([MOVIES]Title;aTitles;[MOVIES]Sold_Tickets;aSoldTickets) ` Inicia o resto das colunas do list box com o propósito de visualizar a informação ARRAY INTEGER(aMovieYear;Size of array(atitles)) ARRAY TEXT(aDirectors;Size of array(atitles)) ARRAY TEXT(aMedias;Size of array(atitles)) ARRAY LONGINT(aNrActors;Size of array(atitles)) SORT ARRAY(aTitles;aDirectors;aMovieYear;aMedias;aSoldTickets;aNrActors;>) Utilizando o comando SQL EXECUTE IMMEDIATE: ARRAY LONGINT(aSoldTickets;0) ARRAY TEXT(aTitles;0) C_TEXT($tQueryTxt) $tquerytxt:="" $tquerytxt:=$tquerytxt+"select Title, Sold_Tickets" $tquerytxt:=$tquerytxt+" FROM MOVIES" $tquerytxt:=$tquerytxt+" WHERE Sold_Tickets > (SELECT AVG(Sold_Tickets) FROM MOVIES)" $tquerytxt:=$tquerytxt+" ORDER BY 1" $tquerytxt:=$tquerytxt+" INTO :atitles, :asoldtickets" Begin SQL EXECUTE IMMEDIATE :$tquerytxt; End SQL ` Inicia o resto das colunas do list box com o propósito de visualizar a informação ARRAY INTEGER(aMovieYear;Size of array(atitles)) ARRAY TEXT(aDirectors;Size of array(atitles)) ARRAY TEXT(aMedias;Size of array(atitles)) ARRAY LONGINT(aNrActors;Size of array(atitles)) Para provar todos os exemplos anteriores, lance a base "4D SQL Code Samples" e vá até a janela principal. Escolha o modo de consulta e pressione o botão Subqueries.

33 Seguimento e depuração do código SQL Em 4D, há duas possibilidades principais para a localização e correção de seu código: ou bem utilizando o para localizar e corrigir qualquer erro ou chamando ao comando ON ERR CALL para capturar o erro e tomar as medidas adequadas. Podemos utilizar estas duas técnicas para resolver os problemas encontrados com o código SQL. Este é um exemplo onde falta um parênteses intencionalmente: no lugar de HAVING SUM(Sold_Tickets <:$MinSoldTickets), temos HAVING SUM(Sold_Tickets <:$MinSoldTickets. ARRAY LONGINT(aSoldTickets;0) ARRAY INTEGER(aMovieYear;0) C_LONGINT($MovieYear;$MinSoldTickets) $MovieYear:=1979 $MinSoldTickets:= Begin SQL SELECT Year_of_Movie, SUM(Sold_Tickets) FROM MOVIES WHERE Year_of_Movie >= :$MovieYear GROUP BY Year_of_Movie HAVING SUM(Sold_Tickets < :$MinSoldTickets ORDER BY 1 INTO :amovieyear, :asoldtickets; End SQL Como você pode ver na janela inferior, a aplicação detecta o erro e abre a que oferece informação mais detalhada sobre o erro e o lugar onde ocorreu. Então é fácil de corrigir somente em pressionar o botão Editar. Se o erro é más complexo, a aplicação oferece mais informação incluindo o conteúdo da pilha, que pode ser vista pressionando o botão Detalhes. Para provar o exemplo anterior, na janela principal da base "4D SQL Code Samples", pressione o botão Depurar o código SQL. A segunda possibilidade principal para o seguimento de erros SQL utiliza o comando ON ERR CALL. Este é um exemplo que instala o método SQL_Error_Handler para detectar erros encontrados no código SQL.

34 ARRAY LONGINT(aSoldTickets;0) ARRAY INTEGER(aMovieYear;0) C_LONGINT($MovieYear;$MinSoldTickets;MySQL_Error) $MovieYear:=1979 $MinSoldTickets:= MySQL_Error:=0 ` Instalação do método SQL_Error_Handler para interceptar os erros ON ERR CALL("SQL_Error_Handler") Begin SQL SELECT Year_of_Movie, SUM(Sold_Tickets) FROM MOVIES WHERE Year_of_Movie >= :$MovieYear GROUP BY Year_of_Movie HAVING SUM(Sold_Tickets < :$MinSoldTickets ORDER BY 1 INTO :amovieyear, :asoldtickets; End SQL ` Desinstalação do método SQL_Error_Handler ON ERR CALL("") O método SQL_Error_Handler é o seguinte: If(MySQL_Error#0) ALERT("SQL Error number: "+String(MySQL_Error)) End if Para provar o exemplo anterior, na janela principal desde a base "4D SQL Code Samples" pressione o botão Using ON ERR CALL.

35 Data Definition Language Usando o SQL Data Definition Language (DDL), pode definir e gerenciar a estrutura da base. Com os comandos DDL, pode criar ou modificar tabelas e campos, assim como adicionar e/ou eliminar dados. Este é um exemplo simples que cria uma tabela, adiciona alguns campos e depois enche os campos com alguns dados. Begin SQL DROP TABLE IF EXISTS ACTOR_FANS; CREATE TABLE ACTOR_FANS (ID INT32, Name VARCHAR); INSERT INTO ACTOR_FANS (ID, Name) VALUES(1, 'Francis'); ALTER TABLE ACTOR_FANS ADD Phone_Number VARCHAR; INSERT INTO ACTOR_FANS (ID, Name, Phone_Number) VALUES (2, 'Florence', ' '); End SQL Para provar o exemplo anterior, na janela principal da base "4D SQL Code Samples", pressione o botão DDL. Nota: Este exemplo somente funcionará uma vez porque se pressionado o botão "DDL" uma segunda vez, será obtida uma mensagem de erro dizendo que a tabela já existe.

36 Conexões Externas 4D permite o uso do banco de dados externos, ou seja executar consultas SQL em outras bases diferentes da base local. Para isso, pode conectar-se a qualquer fonte de dados externa via ODBC ou diretamente a outras bases 4D. Estes são os comandos que permitem as conexões com bancos de dados externos: Get current data source indica a fonte de dados ODBC utilizada pela aplicação. GET DATA SOURCE LIST devolve a lista de fontes de dados ODBC instaladas na máquina. SQL LOGIN lhe permite conectar-se a uma base externa diretamente ou via uma fonte de dados ODBC instalada na máquina. SQL LOGOUT pode ser utilizada para fechar qualquer conexão externa e voltar a conectar-se a base 4D local. USE DATABASE (comando SQL) pode ser utilizada para abrir um banco de dados 4D externa com o motor SQL de 4D. O seguinte exemplo mostra como conectar-se a uma fonte de dados externa (ORACLE), como obter dados da base ORACLE, e depois como desconectar-se da base ORACLE e voltar a base local. Vamos Supor que existe uma fonte de dados válida chamada "Test_ORACLE_10g" instalada no sistema. Para provar o exemplo anterior, na janela principal da base "4D SQL Code Samples", pressione o botão Conectar a ORACLE.

37 Conexão ao motor SQL 4D via o driver ODBC Pode conectar-se ao motor SQL de 4D desde qualquer banco de dados externo via o driver ODBC para 4D. Nota: Esta configuração se utiliza como um exemplo. É possível conectar diretamente as aplicações 4D entre elas via SQL. Para maior informação, consulte a descrição do comando SQL LOGIN. 1. Duplique a base de exemplo que vem com este tutorial 2. Renome as duas pastas que contém as bases, por exemplo "Cliente" e "Servidor". 3. Lance a base de exemplo dentro da pasta Server e ative o lançamento do servidor SQL ao inicio selecionando a opção "Lançar o servidor SQL ao inicio" nas Propriedades da base, página SQL: 4. Feche e reinicie a base de exemplo da pasta Server para ativar o servidor SQL. 5. Instale o driver 4D ODBC Driver for 4D, a continuação, comprove se aparece no Administrador de fontes de dados ODBC: 6. Crie uma nova fonte de dados chamada "Test_ODBC_Driver_v11" e prove pressionando o botão Connection test 7. Lance a base de exemplo dentro da pasta Client, vá até a janela principal e faça clique no botão "Conexão a 4D". O código deste botão é o seguinte: Como você pode ver, na primeira parte do método é feita uma consulta na base local. Depois, na segunda parte, nos conectamos a outra base 4D via o driver ODBC e fazemos a mesma consulta. O resultado deve ser o mesmo, é claro.

38 Utilizar SQL em 4D Esta seção oferece uma vista geral das possibilidades de uso de SQL em 4D. Esta seção descreve os diferentes modos para acessar ao motor SQL integrado, assim como as diferentes formas de executar pesquisas e recuperar dados. Também detalha a configuração do servidor SQL de 4D e apresenta os princípios de implementação do SQL a nível do motor de 4D. Acessar ao motor SQL de 4D Configuração do servidor SQL de 4D Princípios para Integração 4D e motor SQL de 4D Tabelas sistema Replicação via SQL Suporte de joins

39 Acessar ao motor SQL de 4D Envio de petições ao motor SQL de 4D O motor SQL integrado de 4D pode ser chamado de três formas diferentes: Via o comando QUERY BY SQL. Passe a cláusula WHERE de um comando SQL SELECT como um parâmetro pesquisa. Exemplo: QUERY BY SQL([OFFICES];"SALES > 100") Via os comandos SQL integrados de 4D, localizados no tema "SQL" (SQL SET PARAMETER, SQL EXECUTE, etc.). Estes comandos podem trabalhar com uma fonte de dados ODBC ou o motor SQL de 4D do banco de dados atual. Via o editor de métodos padrão de 4D. As instruções SQL podem ser escritas diretamente no editor de métodos padrão de 4D. Simplesmente deve inserir a consulta SQL entre as etiquetas: Begin SQL e End SQL. O código entre estas etiquetas não será analisado pelo intérprete de 4D e será executado pelo motor SQL (ou por outro motor, é definido pelo comando SQL LOGIN). Passar dados entre 4D e o motor SQL Referenciar as expressões 4D É possível fazer referencia a todo tipo de expressão 4D válida (variável, campo, array, expressão...) dentro das cláusulas WHERE e INTO das expressões SQL. Para indicar uma referencia 4D, pode utilizar qualquer das seguintes notações: Colocar a referencia entre símbolos duplos menor que e maior que como é visto aqui << e >> Colocar dois pontos ":" na frente da referencia. Exemplos: ou: Notas: C_STRING(80;vNome) vnome:=request("nome:") SQL EXECUTE("SELECT age FROM PEOPLE WHERE nome=<<vnome>>") C_STRING(80;vNome) vnome:=request("nome:") Begin SQL SELECT age FROM PEOPLE WHERE name= :vnome End SQL O uso de colchetes [] é necessário quando trabalha com variáveis interprocessos (por exemplo, <<[<>mivar]>> ou: [<>mivar]). Uso de variáveis em modo compilado Em modo compilado, pode utilizar referencias de variáveis locais (começando pelo caractere $) em instruções SQL sob certas condições: Pode utilizar variáveis locais dentro de uma sequência Begin SQL / End SQL, exceto com o comando EXECUTE IMMEDIATE; Pode utilizar variáveis locais com o comando SQL EXECUTE quando estas variáveis se utilizam diretamente no parâmetro de petição SQL e não via as referencias. Por exemplo, o seguinte código funciona em modo compilado: SQL EXECUTE("select * from t1 into :$myvar") // funciona em modo compilado O seguinte código irá falhar em modo compilado: C_TEXT(tRequest)

40 trequest:="select * from t1 into :$myvar" SQL EXECUTE(tRequest) // erro em modo compilado Recuperar os dados das petições SQL em 4D A recuperação de dados em uma instrução SELECT será gerenciada dentro das etiquetas Begin SQL/End SQL sob a cláusula INTO do comando SELECT ou sob os comandos 4D do tema "SQL". No caso das etiquetas Begin SQL/End SQL, pode utilizar a cláusula INTO da consulta SQL e fazer referencia a qualquer expressão válida 4D (campo, variável, array) para obter o valor: Begin SQL SELECT ename FROM emp INTO <<[Empregados]Nome>> End SQL Com o comando SQL EXECUTE, também pode utilizar os parâmetros adicionais: SQL EXECUTE("SELECT ename FROM emp";[empregados]nome) A principal diferença entre estas duas maneiras de obter os dados de SQL (etiquetas Begin SQL/End SQL e comandos SQL) é que no primeiro caso toda a informação é enviada novamente a 4D em um só passo, enquanto no segundo caso, os registros deverão ser carregados de forma explícita utilizando o comando SQL LOAD RECORD. Por exemplo, supondo que na tabela PESSOAS há 100 registros: Usando os comandos SQL genéricos de 4D: ARRAY INTEGER(anoNascimento;0) C_STRING(40;vNome) vnome:="smith" $SQLStm:="SELECT Birth_Year FROM PEOPLE WHERE ename= <<vnome>>" SQL EXECUTE($SQLStm;anoNascimento) While(Not(SQL End selection)) SQL LOAD RECORD(10) End while Aqui temos que realizar 10 laços para recuperar os 100 registros. Se deseja carregar todos os registros em um só passo devemos utilizar: SQL LOAD RECORD(SQL all records) Usando as etiquetas Begin SQL/End SQL: ARRAY INTEGER(anoNascimento;0) C_STRING(40;vNome) vnome:="smith" Begin SQL SELECT Birth_Year FROM PEOPLE WHERE ename= <<vname>> INTO <<anonascimento>> End SQL Nesta situação, depois da execução da instrução SELECT, o array anonascimento contém 100 elementos e cada elemento armazena um ano de nascimento de todos os 100 registros. Se no lugar de um array, queremos armazenar os dados recuperados em uma coluna (um campo 4D), então 4D criará automaticamente tantos registros como seja necessário para salvar todos os dados. Em nosso exemplo anterior, supondo que na tabela PESSOAS há 100 registros: Usando os comandos SQL genéricos de 4D: C_STRING(40;vNome) vnome:="smith" $SQLStm:="SELECT Birth_Year FROM PEOPLE WHERE ename= <<vnome>> SQL EXECUTE($SQLStm;[MINHATABELA]Ano_Nascimento) While(Not(SQL End selection)) SQL LOAD RECORD(10)

41 End while Aqui temos que realizar 10 laços para recuperar todos os 100 registros. Cada passada pelo laço cria 10 registros na tabela [MINHATABELA] e cada valor Ano_Nascimento recuperado da tabela PESSOAS será salvado no campo Ano_Nascimento. Usando as etiquetas Begin SQL/End SQL: C_STRING(40;vNome) vnome:="smith" Begin SQL SELECT Birth_Year FROM PEOPLE WHERE ename= <<vnome>> INTO <<[MINHATABELA]Ano_Nascimento>> End SQL Neste caso, durante a execução da instrução SELECT, serão criados 100 registros na tabela [MINHATABELA] e cada campo Ano_Nascimento conterá os dados correspondentes da tabela PESSOAS, coluna Birth_Year.. Uso de um listbox 4D inclui um funcionamento automático específico (palavra chave LISTBOX) que permite colocar os dados das consultas SELECT em um list box. Para maior informação, consulte o Manual de Desenho. Otimização das petições Por razões de otimização, é preferível utilizar expressões 4D em lugar de funções SQL nas consultas. As expressões 4D serão calculadas uma vez antes da execução da consulta enquanto as funções SQL serão avaliadas para cada registro encontrado. Por exemplo, com a seguinte instrução: SQL EXECUTE("SELECT nomecompleto FROM PEOPLE WHERE nomecompleto=<<vsobrenome+vnome>>")... a expressão vsobrenome+vnome é calculada uma vez, antes da execução da consulta. Com a seguinte instrução: SQL EXECUTE("SELECT nomecompleto FROM PEOPLE WHERE nomecompleto=concat(<<vsobrenome>>,<<vnome>>)")... a função CONCAT(<<vSobrenome>>,<<vNome>>) é chamada para cada registro da tabela, ou seja, a expressão é avaliada para cada registro.

42 Configuração do servidor SQL de 4D O servidor SQL de 4D permite o acesso externo aos dados armazenados na base 4D. Para as aplicações de terceiras partes e as aplicações 4D, este acesso é realizado mediante um driver ODBC 4D. Também é possível realizar conexões diretas entre uma aplicação cliente 4D e 4D Server. Todas as conexões são feitas usando o protocolo TCP/IP. O servidor SQL de uma aplicação 4D pode ser detida ou iniciada em qualquer momento. Além disso, por motivos de rendimento e segurança, pode especificar a porta TCP e o endereço IP de escuta e restringir as possibilidades de acesso ao banco de dados 4D. Acesso externo ao servidor SQL O acesso externo ao servidor SQL de 4D pode ser realizado via ODBC (todas as configurações), ou diretamente (aplicação cliente 4D conectado a 4D Server). Isto se resume no seguinte diagrama: Em azul: conexões via ODBC Em vermelho: conexões diretas A nível de pesquisas, a abertura de uma conexão externa ou via ODBC é levada a cabo utilizando o comando SQL LOGIN. Para maior informação, consulte a descrição deste comando. Conexões via ODBC: 4D oferece um driver ODBC que permite a toda aplicação de terceiros (folha de cálculo de tipo Excel, outros DBMS, etc.) ou qualquer outra aplicação 4D se conecta ao servidor SQL de 4D. O driver ODBC 4D deve ser instalado na máquina da parte SQL cliente. A instalação e configuração do driver ODBC 4D é detalhada em outro manual. Conexões diretas: só uma aplicação 4D Server pode responder as consultas SQL diretas precedentes de outras aplicações 4D. Da mesma forma, só as aplicações 4D de gama "Profissional" podem abrir uma conexão direta a outra aplicação 4D. Durante uma conexão direta, a troca de dados é realizada automaticamente em modo síncrono, que elimina as questões relacionadas com a sincronização e a integridade dos dados. Só uma conexão está autorizado por processo. Se deseja estabelecer várias conexões simultâneas, deve criar tantos processos como seja necessário. As conexões diretas, pode estar seguro selecionando a opção Ativar SSL no lado do objetivo da conexão (4D Server) na página "SQL" das Propriedades da base. As conexões diretas só estão autorizadas por 4D Server se o servidor SQL está ativo. A principal vantagem das conexões diretas é que se aceleram as trocas de dados. Iniciar e parar o servidor SQL O servidor SQL de 4D pode ser iniciado ou detido de três formas: Manualmente, utilizando os comandos Arrancar o servidor SQL/Parar o servidor SQL no menu Executar da aplicação 4D: Nota: Com 4D Server, pode acessar a este comando como botão na Página Servidor SQL. Quando é lançado o servidor, esta opção de menu muda a Parar o servidor SQL.

43 Automaticamente ao inicio da aplicação, via as Propriedades da base. Para fazer isso, mostre a página SQL e selecione a opção Lançar o servidor SQL ao início: Por programação, usando os comandos START SQL SERVER e STOP SQL SERVER (tema ). Quando o servidor SQL está parado (ou quando não foi iniciado), 4D não responderá a nenhuma consulta SQL externa. Nota: Parar o servidor SQL não afeta o funcionamento interno do motor SQL de 4D. O motor SQL sempre está disponível para as consultas internas. Preferências de publicação do servidor SQL É possível configurar os parâmetros de publicação do servidor SQL integrado de 4D. Estes parâmetros se encontram na página SQL das Propriedades do banco: A opção Iniciar o servidor SQL ao iniciar permite iniciar o servidor SQL ao início da aplicação. Porta TCP: como padrão, o servidor SQL de 4D responde às requisições na porta TCP Se esta porta já está sendo utilizada por outro serviço, ou se seus parâmetros de conexão requerem outra configuração, pode modificar a porta TCP utilizada pelo servidor SQL de 4D. Nota: - se digitar 0, 4D utilizará o número de porta TCP como padrão, ou seja, Pode definir este valor por programação utilizando o seletor SQL Server Port ID do comando SET DATABASE PARAMETER. Endereço IP: permite definir o endereço IP da máquina na qual o servidor SQL deve processar as consultas SQL. Como padrão, o servidor responderá a todos os endereços IP (opção Todos). A lista pop-up "Endereço IP" contém automaticamente todos os endereços IP presentes na máquina. Quando é selecionada uma direção em particular, o servidor somente responderá às consultas enviadas a este endereço. Esta funcionalidade está dirigida às aplicações 4D hospedadas em máquinas com várias direções TCP/IP. Notas: Do lado do cliente, a direção IP e a porta TCP do servidor SQL para que a aplicação se conecte devem estar corretamente configurados na definição da fonte de dados ODBC. A partir de 4D v14, o servidor SQL suporta a notação de endereços IPv6. O servidor aceita indiferentemente as conexões IPv6 ou IPv4 quando a configuração "Endereço IP" de escuta do servidor é Todas. Para obter mais informação, consulte a seção Suporte de IPv6.

44 Ativar SSL: esta opção indica se o servidor SQL deve ativar o protocolo SSL para o processamento das conexões SQL. Note que quando esse protocolo está ativado, você deve adicionar a palavra chave ":ssl" ao final do endereço IP do servidor SQL quando você abre a conexão usando o comando SQL LOGIN. Por padrão, o servidor SQL usa arquivos internos para a chave SSL e certificado. Você pode, entretanto, usar elementos personalizados: para fazer isso, apenas copie seus arquivos key.pem e cert.pem de 4D na seguinte localização: MeuBanco/Preferencias/SQL (onde "MeuBanco" representa a pasta/pacote do banco). Autorizar as requisições Flash Player: esta opção permite ativar o mecanismo de suporte às requisições Flash Player pelo servidor SQL de 4D. Este mecanismo é baseado na presença de um arquivo, chamado "socketpolicy.xml," na pasta preferências do banco (Preferencias/SQL/Flash/). Este arquivo é pedido pelo Flash Player para permitir conexões entre domínios ou conexões por aplicações sockets Flex (Web 2.0). Na versão anterior de 4D, este arquivo tinha que se agregar manualmente. A partir de agora, a ativação se realiza utilizando a opção Autorizar as requisições Flash Player: ao ativar esta opção, as requisições Flash Player são aceitas e um arquivo "socketpolicy.xml" genérico é criado para o banco se é necessário. Nota: é possível definir a codificação utilizada pelo servidor SQL para o processamento de requisições externas utilizando o comando 4D SQL SET OPTION. Controle do acesso SQL para o esquema por padrão Por razões de segurança, é possível controlar as ações que as consultas externas enviadas ao servidor SQL podem realizar no banco de dados 4D. Este controle se realiza em dois níveis: Ao nível do tipo de ação autorizada; Ao nível do usuário que faz a consulta. Estes ajustes podem ser feitos na página SQL das Propriedades do banco: Nota: Pode utilizar o Método de base On SQL Authentication para controlar de forma personalizada as petições externas ao motor SQL de 4D. Os parâmetros definidos nesta caixa de diálogo são aplicados ao esquema (Schema) como padrão. O controle dos acessos externos ao banco se baseiam no conceito de esquemas SQL (ver a seção Princípios para Integração 4D e motor SQL de 4D). Se não criar esquemas personalizados, o esquema padrão inclui todas as tabelas do banco. Se criar outros esquemas com os direitos de acesso específicos e os associa com as tabelas, o esquema por padrão somente incluirá as tabelas que não estão incluídas nos esquemas personalizados. Pode configurar três tipos distintos de acesso ao esquema por padrão através do servidor SQL: "Somente leitura (dados)": acesso ilimitado na leitura a todos os dados das tabelas do banco mas não está permitido adicionar, modificar ou eliminar registros, nem modificar a estrutura do banco. Leitura/escrita (dados)": acesso em leitura e escrita (adicionar, modificar e apagar) a todos os dados das tabelas de banco, mas não é possível modificar a estrutura do banco. "Completo (dados e estrutura)": acesso em leitura e escrita (adicionar, modificar e apagar) a todos os dados das tabelas do banco, assim como à modificação da estrutura do banco (tabelas, campos, relações, etc.). Pode designar um conjunto de usuários para cada tipo de acesso. Há três opções disponíveis para este propósito: <Ninguém>: se selecionar esta opção, o tipo de acesso será negado para todas as consultas, independentemente de sua origem. Este parâmetro pode ser utilizado mesmo quando o sistema de gestão de acesso por senhas de 4D não estiver ativo. <Todos>: se selecionar esta opção, o tipo de acesso se aceitará para todas as consultas (sem limites). Grupo de usuários: esta opção permite criar um grupo de usuários autorizados a realizar o tipo de acesso atribuído. Esta opção requer que a gestão de senhas de 4D esteja ativada. O usuário que realiza as consultas dá seu nome e senha durante a conexão ao servidor SQL. ADVERTÊNCIA: cada tipo de acesso está definido de forma independente dos outros. Mais especificamente, se só atribui o tipo de acesso Só leitura a um grupo este não terá nenhum efeito já que este grupo, assim como também todos os outros vão continuar se beneficiando do acesso Leitura/escritura (atribuído a <Todo o mundo> de forma pré determinada). Com o propósito de definir um acesso Só leitura, também é necessário o acesso Leitura/escritura. ADVERTÊNCIA: este mecanismo se baseia nas senhas de 4D. Para que o controle de acesso ao servidor SQL tenha efeito, o sistema de senhas de 4D deve estar ativo (uma senha deve ser atribuída ao Designer). Nota: uma opção de segurança adicional pode ser estabelecida ao nível de cada método de projeto 4D. Para obter mais informação, consulte o parágrafo "Opção Disponível através SQL" da seção.

45 Princípios para Integração 4D e motor SQL de 4D Basicamente, o motor SQL de 4D é compatível com SQL-92. Isto significa que para uma descrição detalhada dos comandos, funções, operadores e sintaxes a utilizar, pode se referir a documentação do SQL-92. Múltiplos recursos sobre este tema estão disponíveis em Internet. No entanto, o motor SQL de 4D não suporta o 100% das funções do SQL-92 e oferece outras funções adicionais específicas. Esta seção cobre as principais implementações e limitações do motor SQL de 4D. Limitações gerais Uma vez que o motor SQL de 4D foi integrado no coração do banco de dados de 4D, todas as limitações relativas ao número máximo de tabelas, colunas (campos) e registros por base, assim como as regras para dar nomes as tabelas e colunas, são as mesmas as do motor padrão de 4D. São enumeradas a continuação. Número máximo de tabelas: teoricamente dois bilhões, mas por razões de compatibilidade com 4D: Número máximo de colunas (campos) por tabela: teoricamente dois bilhões de colunas (campos), mas por razões de compatibilidade com 4D: Número máximo de linhas (registros) por tabela: um bilhão. Número máximo de chaves de índice: um bilhão x 64. Uma chave primária não pode ser um valor NULL e deve ser única. Não é necessário indexar as colunas (campos) chaves primárias. Número máximo de caracteres permitido para os nomes de tabelas e campos: 31 caracteres (limitação 4D). Não está permitido criar várias tabelas com o mesmo nome. Aplica o mecanismo de controle padrão de 4D. Tipos de dados A seguinte tabela indica os tipos de dados suportados no SQL de 4D assim como seu tipo correspondente em 4D: Tipo 4D SQL 4D Varchar Texto Alfanumérico Texto ou Alfa Real Número de ponto flutuante no faixa de +/-1.7E308 Real Numeric Número entre +/- 2E64 Inteiro 64 bits Float Número de ponto flutuante (virtualmente infinito) Float Smallint Número entre e Inteiro Int Número entre e Inteiro longo, Inteiro Int64 Número entre +/- 2E64 Inteiro 64 bits UUID Número de 16 bytes (128 bits) contém 32 caracteres hexadecimais Alpha format UUID Bit Campo que só aceita os valores TRUE/FALSE ou 1/0 Booleano Boolean Campo que só aceita os valores TRUE/FALSE ou 1/0 Booleano Blob Hasta 2 GB; todo objeto binário tal como uma imagem, um documento, uma aplicação Blob Bit varying Até 2 GB; todo objeto binário tal como uma imagem, um documento, uma aplicação Blob Clob Até 2 GB de texto. Esta coluna (campo) não pode ser indexada. Não é salvada no registro mesmo. Texto Text Até 2 GB de texto. Esta coluna (campo) não pode ser indexada. Não é salvada no registro mesmo. Texto Timestamp Data em formato 'YYYY/MM/DD' e hora em formato Partes Data e Hora gerados separadamente 'HH:MM:SS:ZZ' (conversão automática) Duration Duração em formato 'HH:MM:SS:ZZ' Hora Interval Duração em formato 'HH:MM:SS:ZZ' Hora Picture Imagem PICT até de 2 GB Imagem A conversão entre os tipos de dados numéricos é automática. As cadeias que representam um número não se convertem em um número correspondente. Existem funções CAST especiais que converterão os valores de um tipo a outro.

46 Os seguintes tipos de dados SQL não são implementados: NCHAR NCHAR VARYING. Valores NULL em 4D Os valores NULL se implementam na linguagem SQL de 4D, assim como no motor de banco de dados de 4D. No entanto, não são suportados na linguagem 4D. No entanto, é possível ler e escrever valores NULL em um campo 4D utilizando os comandos Is field value Null e SET FIELD VALUE NULL. Compatibilidade dos processos e opção Traduzir os NULL em valores vazios Por razões de compatibilidade em 4D, os valores NULL armazenados nas tabelas do banco de dados 4D se converte automaticamente em valores por padrão quando é manipulado sob a linguagem 4D. Por exemplo, no caso da seguinte instrução: mivaralf:=[minhatabela]meucampoalfa... se o campo MeuCampoAlfa contém um valor NULL, a variável mivaralfa conterá "" (cadeia vazia). Os valores por padrão dependem do tipo de dado: Para os tipos Alfa e Texto: "" Para os tipos Real, Inteiro e Inteiro longo: 0 Para o tipo Data: "00/00/00" Para o tipo Hora: "00:00:00" Para o tipo Booleano: Falso Para o tipo Imagem: Imagem vazia Para o tipo BLOB: BLOB vazio Por outra parte, este mecanismo, em princípio, não se aplica aos tratamentos realizados a nível do motor do banco de dados 4D, tais como as consultas. Na verdade, a pesquisa de um valor "vazio" (por exemplo meuvalor = 0) não encontra registros que armazenem o valor NULL e vice-versa. Quando os dois tipos de valores (valores por padrão e NULL) estão presentes nos registros para um mesmo campo, alguns processos podem ser alterados ou necessitar código adicional. Para evitar estes inconvenientes, uma opção permite padronizar todos os procedimentos da linguagem 4D: Mapear valores NULOS a valores vazios. Esta opção, que é encontrada na janela Inspetor de campos do editor de estrutura, permite estender o princípio de utilizar os valores por padrão em todos os tratamentos. Os campos que contenham valores NULL se consideram sistematicamente que contém valores por padrão. Esta opção está selecionada por padrão. A propriedade Mapear valores NULOS a valores vazios é levado em conta a um nível muito baixo do motor do banco de dados. Atua mais particularmente no comando Is field value Null. Rejeitar valor NULO de entrada A propriedade de campo Rejeitar valor NULO de entrada permite evitar o armazenamento de valores NULL: Quando este atributo está selecionado para um campo, não será possível armazenar o valor NULL neste campo. Esta propriedade de baixo nível corresponde exatamente ao atributo NOT NULL de SQL. Geralmente, se deseja poder utilizar os valores NULL em seu banco de dados 4D, se recomenda utilizar exclusivamente a linguagem SQL de 4D. Nota: Em 4D, os campos também podem ter o atributo "Obrigatório". Os dois conceitos são similares, mas seu alcance é diferente: o atributo "obrigatório" é um controle de entrada, ainda que o atributo "Rejeitar valor NULO de entrada" trabalha ao nível do motor do banco de dados. Se um campo com este atributo recebe um valor NULL, é gerado um erro.

47 Constantes data e hora O servidor SQL integrado de 4D suporta as constantes data e hora de acordo ao API ODBC. Esta é a sintaxe para as sequências de constantes data e hora ODBC: {constant_type 'value'} tipo_constante valor d aaaa-mm-dd Data unicamente t hh:mm:ss[.fff] Hora unicamente ts aaaa-mm-dd hh:mm:ss[.fff] Data e hora (timestamp) Note: fff indica milissegundos. Por exemplo, pode utilizar as seguintes constantes: { d ' ' } { t '13:33:41' } { ts ' :23:56.123' } Opção Disponível via SQL Uma propriedade de segurança foi adicionada para os métodos projeto 4D: Disponível via SQL: Quando está selecionada, esta opção permite a execução do método de projeto pelo motor SQL de 4D. Não está selecionada por padrão, o que significa que os métodos projeto 4D estão protegidos e não podem ser chamados pelo motor SQL de 4D a menos que tenha sido expressamente autorizado ao selecionar esta opção. Esta propriedade se aplica a todas as consultas SQL, tanto internas como externas, se executada via o driver ODBC, o código SQL inserido entre as etiquetas Begin SQL/End SQL, ou via o comando QUERY BY SQL. Notas: Inclusive quando um método tem o atributo "Disponível via SQL", os direitos de acesso definidos a nível das Propriedades da base e as propriedades do método são levadas em consideração durante sua execução. A função ODBC SQLProcedure devolve unicamente os métodos projeto que têm o atributo "Disponível via SQL". Opções do motor SQL Transações Auto-commit: esta opção permite ativar o mecanismo de auto-commit no motor SQL. O propósito do modo auto-commit é preservar a integridade referencial dos dados. Quando esta opção estiver selecionada, toda pesquisa SELECT, INSERT, UPDATE e DELETE (SIUD) não realizada dentro de uma transação se inclui automaticamente em uma operação ad hoc. Isso garante que as consultas se executarão em sua totalidade ou em caso de erro, se cancelarão totalmente.

48 As consultas incluídas em uma transação (gestão personalizada da integridade referencial) não se verão afetadas por esta opção. Quando esta opção não estiver selecionada, não se geram transações automáticas (exceto para as consultas SELECT... FOR UPDATE, consulte o comando SELECT). Como padrão, esta opção não está selecionada. Também pode administrar esta opção por programação utilizando o comando SET DATABASE PARAMETER. Nota: somente os bancos locais consultados pelo motor SQL de 4D se vêm afetados por este parâmetro. No caso das conexões externas a outros bancos de dados SQL, o mecanismo de auto-commit é manejado pelos motores SQL remotos. Levar em consideração as maiúsculas e minúsculas nas comparações de cadeias de caracteres: esta opção permite modificar a sensibilidade às maiúsculas e minúsculas dos caracteres nas consultas SQL. Está selecionada como padrão, o que significa que o motor SQL diferencia entre maiúsculas e minúsculas quando se comparam strings (ordenações e pesquisas). Por exemplo, "ABC" = "ABC", mas "ABC" # Abc "." Em alguns casos, por exemplo para alinhar o funcionamento do motor SQL com o do motor 4D, é possível que deseje que as comparações de cadeias de caracteres não sejam sensíveis às maiúsculas ("ABC" = "Abc"). Para isso, apenas deve desmarcar esta opção. Também pode administrar esta opção por programação utilizando o comando SET DATABASE PARAMETER. Esquemas 4D implementa o conceito de esquemas. Um esquema é um objeto virtual que contém as tabelas da base. No SQL, o propósito dos esquemas é atribuir direitos de acesso específicos aos diferentes conjuntos de objetos da base. Os esquemas dividem a base em entidades independentes que em conjunto formam toda a base. Em outras palavras, uma tabela sempre pertence a um só esquema. Para criar um esquema, deve utilizar o comando CREATE SCHEMA. A continuação, pode utilizar os comandos GRANT e REVOKE para configurar os tipos de acesso aos esquemas. Para associar uma tabela a um esquema, pode chamar aos comandos CREATE TABLE ou ALTER TABLE. Também pode usar o menu pop-up "Esquemas" do Inspetor do editor de estrutura de 4D, que lista todos os esquemas definidos na base: O comando DROP SCHEMA permite eliminar um esquema Nota: O controle de acesso sob os esquemas somente é aplicado as conexões desde o exterior. O código SQL executado em 4D via as etiquetas Begin SQL/End SQL, SQL EXECUTE, QUERY BY SQL, sempre têm acesso total. Conexões as fontes SQL A arquitetura multi-bases se implementa a nível do servidor SQL de 4D. Desde 4D é possível: Conectar-se a uma base existente utilizando o comando SQL LOGIN. Passar de uma a outra utilizando os comandos SQL LOGIN e SQL LOGOUT. Para abrir e utilizar outra base 4D em lugar da base atual utilizando o comando USE DATABASE. Chave primária Na linguagem SQL, uma chave primária permite identificar em uma tabela a(s) coluna(s) (campos) responsáveis de designar de maneira única os registros (linhas). A definição de uma chave primária é particularmente necessária para a função de replicação dos registros de uma tabela de 4D (ver a seção Replicação via SQL) e para o histórico das tabelas 4D a partir da v14. 4D lhe permite administrar a chave primária de uma tabela de duas formas: Via a linguagem SQL Utilizando o editor de estrutura de 4D. Nota: também pode definir chaves primárias utilizando Criar uma estrutura de banco de dados de 4D no modo Desenho. Definir a chave primária via a linguagem SQL Pode definir uma chave primária durante a criação de uma tabela (via o comando CREATE TABLE) ou ao agregar ou modificar uma coluna (via o comando ALTER TABLE). A chave primária se define utilizando a cláusula PRIMARY KEY seguida pelo nome da coluna ou de uma lista de colunas. Para obter mais informação, consulte a seção. Definir a chave primária via o editor de estrutura 4D lhe permite criar e excluir diretamente chaves primárias via o menu contextual do editor da estrutura. Para criar uma chave primária: 1. Selecione ele ou os campo(s) que compõe a chave primária da tabela. 2. Faça clique direito e escolha o comando Criar a chave primária no menu contextual:

49 Os campos incluídos na chave primária aparecem sublinhados no editor e sua descrição SQL mostra a palavra chave PRIMARY KEY. Ele ou os campo(s) que pertence(m) a chave primária não deve conter valores duplicados. Se já existem valores duplicados nos registros de tabela, aparece uma caixa de diálogo de advertência. Nota: A ou as coluna(s) que pertence(m) a chave primária não aceitam valores NULL. Para excluir a chave primária de uma tabela: 1. Faça clique direito sobre a tabela que contém a chave primária e escolha o comando Suprimir a chave primária no menu contextual: Aparece uma caixa de diálogo de confirmação. Se fizer clique em Aceitar, a chave primária é excluída imediatamente. Vistas SQL O motor SQL integrado de 4D suporta vistas SQL padrão. Uma vista é uma tabela virtual com dados que podem proceder de várias tabelas das bases de dados. Uma vez que se define uma vista, pode utilizar em uma instrução SELECT como uma tabela real. Os dados se encontram em uma vista se definem mediante uma petição de definição baseada no comando SELECT. As tabelas reais utilizadas na consulta de definição são chamadas "tabelas fontes". Uma vista SQL contém colunas e linhas como uma tabela estandarte, mas em realidade não existe, mas é só uma representação resultante do processamento e se armazena na memória. Só a definição da vista é armazenada na base. Dois comandos SQL se utilizam para administrar vistas em 4D v14: Comandos SQL e DROP VIEW.

50 Tabelas sistema Tabelas sistema O catálogo SQL de 4D inclui sete tabelas sistema, acessíveis por todo usuário SQL que tenha acesso de leitura: _USER_TABLES, _USER_COLUMNS, _USER_INDEXES, _USER_CONSTRAINTS, _USER_IND_COLUMNS, _USER _CONS_ COLUMNS, _USER_SCHEMAS, _USER_VIEWS y _USER_VIEW_COLUMNS. Conforme aos usos no mundo SQL, as tabelas sistema descrevem a estrutura do banco de dados. Esta é uma descrição destas tabelas e seus campos: _USER_TABLES Descreve as tabelas usuário da base TABLE_NAME VARCHAR Nome de tabela TEMPORARY BOOLEAN True se a tabela é temporal; caso contrário, false TABLE_ID INT64 Número de tabela SCHEMA_ID INT32 Número de esquema REST_AVAILABLEBOOLEANTrue se a coluna está exposta com o serviço REST; caso contrário, False[#/table] _USER_COLUMNS Descreve as colunas das tabelas usuários da base TABLE_NAME VARCHAR Nome de tabela COLUMN_NAME VARCHAR Nome de coluna DATA_TYPE INT32 Tipo de coluna DATA_LENGTH INT32 Largo da coluna NULLABLE BOOLEAN True se a coluna aceita valores NULL; caso contrário, false TABLE_ID INT64 Número de tabela COLUMN_ID INT64 Número de coluna UNIQUENESSBOOLEANTrue se a coluna se declara única; caso contrário, False AUTOGENERATEBOOLEANTrue se o valor da coluna é gerado automaticamente para cada novo registro; caso contrário, False AUTOINCREMENTBOOLEANTrue se o valor da coluna se incrementa automaticamente; caso contrário, False REST_AVAILABLEBOOLEANTrue se a coluna está exposta com o serviço REST; caso contrário, False[#/table] _USER_INDEXES Descreve os índices usuários da base INDEX_ID VARCHAR Número de índice INDEX_NAME VARCHAR Nome de índice INDEX_TYPE INT32 Tipo de índice (1=BTree / Composite, 3=Cluster / Palavras chaves, 7=Auto) KEYWORD BOOLEAN True se o índice é um índice de palavras chaves; caso contrário, False TABLE_NAME VARCHAR Nome da tabela com índice UNIQUENESS BOOLEAN True se o índice impõe uma restrição de singularidade; caso contrário, false TABLE_ID INT64 Número de tabela com índice _USER_IND_COLUMNS Descreve as colunas de índices usuários da base INDEX_ID VARCHAR Número de índice INDEX_NAME VARCHAR Nome de índice TABLE_NAME VARCHAR Nome de tabela com índice COLUMN_NAME VARCHAR Nome de coluna com índice COLUMN_POSITION INT32 Posição de coluna no índice TABLE_ID INT64 Número de tabela com índice COLUMN_ID INT64 Número de coluna _USER_CONSTRAINTS Descreve as restrições usuários da base CONSTRAINT_ID VARCHAR Número de restrição CONSTRAINT_NAME VARCHAR Nome de restrição CONSTRAINT_TYPE VARCHAR Tipo de restrição TABLE_NAME VARCHAR Nome de tabela com restrição TABLE_ID INT64 Número de tabela com restrição DELETE_RULE VARCHAR Regra de supressão CASCADE ou RESTRICT RELATED_TABLE_NAME VARCHAR Nome de tabela relacionada RELATED_TABLE_ID INT64 Número de tabela relacionada

51 _USER_CONS_COLUMNS Descreve as colunas de restrições usuários da base CONSTRAINT_ID VARCHAR Número de restrição CONSTRAINT_NAME VARCHAR Nome de restrição TABLE_NAME VARCHAR Nome de tabela com restrição TABLE_ID INT64 Número de tabela com restrição COLUMN_NAME VARCHAR Nome de coluna com restrição COLUMN_ID INT64 Número de coluna com restrição COLUMN_POSITION INT32 Posição de coluna com restrição RELATED_COLUMN_NAME VARCHAR Nome de coluna relacionada em uma restrição RELATED_COLUMN_ID INT32 Número de coluna relacionada em uma restrição _USER_SCHEMAS Descreve os esquemas da base SCHEMA_ID INT32 Número do esquema SCHEMA_NAME VARCHAR Nome do esquema READ_GROUP_ID INT32 Número do grupo com acesso só a leitura READ_GROUP_NAME VARCHAR Nome do grupo com acesso a leitura-escritura READ_WRITE_GROUP_ID INT32 Número do grupo com acesso a leitura-escritura READ_WRITE_GROUP_NAME VARCHAR Nome do grupo having read-write access ALL_GROUP_ID INT32 Número do grupo com acesso completo ALL_GROUP_NAME VARCHAR Nome do grupo com acesso completo _USER_VIEWS Descreve as vistas dos usuários da base VIEW_NAME VARCHAR Nome de vista SCHEMA_ID INT32 ID do nom_schema ao qual pertence a vista _USER_VIEW_COLUMNS Descreve as colunas das vistas dos usuários da base VIEW_NAME VARCHAR Nome de vista COLUMN_NAME VARCHAR Nome de coluna DATA_TYPE INT32 Tipo de coluna DATA_LENGTH INT32 Tamanho de coluna NULLABLE BOOLEAN True se coluna aceita os valores NULL; caso contrário, False Nota: As tabelas sistema são atribuídas a um esquema particular chamado SYSTEM_SCHEMA. Este esquema não pode ser modificado ou apagado. Não aparece na lista de esquemas mostrada no inspetor de tabelas. É acessível em modo leitura unicamente por todos os usuários.

52 Replicação via SQL 4D oferece um mecanismo que permite replicar ou sincronizar os dados de duas ou mais bases 4D via SQL. Esta funcionalidade específica pode ser utilizada para criar uma ou mais bases espelhos, garantindo a disponibilidade permanente dos dados. O principio é o seguinte: um banco de dados objetivo replica no local os dados de um banco de dados fonte remota. As atualizações serão levadas a cabo periodicamente pela base local que recupera os dados da base remota. A replicação é levada a cabo a nível de tabela: Você replica os dados de uma tabela da base remota em uma tabela da base local. Isto é possível graças a utilização de marcadores (stamps) e de comandos SQL específicos. No editor da estrutura, uma propriedade de tabela permite ativar o mecanismo de replicação na base remota e local. Do lado da base local, o comando SQL REPLICATE permite recuperar dados de uma tabela da base remota e depois integrar estes dados em uma tabela da base local. O comando SQL SYNCHRONIZE, é utilizado para levar a cabo a sincronização das duas tabelas. Campos virtuais Cada tabela da base 4D pode ser atribuída com três campos "virtuais": ROW_ID, ROW_STAMP e ROW_ACTION. Estes campos são chamados "virtuais" para os diferenciar dos "clássicos" porque têm propriedades específicas: preenchem automaticamente, pode ser lido mas não modificado pelos usuários e não aparecem nas tabelas sistema da base. A seguinte tabela descreve estes campos, assim como seu modo de uso: Campo virtual Tipo Conteúdo Uso ROW_ID Int32 ID do registro Em toda instrução SQL exceto REPLICATE ou SYNCHRONIZE ROW_STAMP Int64 Informação de replicação do registro Em toda instrução SQL ROW_ACTION Int16 Tipo de ação realizada no registro: 1 = Adição ou Unicamente com o comando REPLICATE modificação, 2 = Supressão ou SYNCHRONIZE Quando os mecanismos de replicação estão ativos, logo como um registro é criado, modifica ou elimina, a informação correspondente é atualizada automaticamente nos campos virtuais deste registro. Ativar replicação Por padrão os mecanismos que permitem a replicação não estão ativos. Você deve ativá-los explicitamente tanto na base remota e na base local para cada tabela utilizada na replicação ou sincronização. Tenha em conta que a ativação do mecanismo não ativa a replicação, com o propósito de que os dados se repliquem em uma base local ou sincronizada, deve utilizar os comandos REPLICATE ou SYNCHRONIZE. Para ativar o mecanismo interno de replicação, deve utilizar em cada tabela (na base remota e local), a propriedade de tabela Ativar replicação acessível no Inspetor de tabelas: Nota: Para que o mecanismo de replicação possa funcionar, deve especificar uma chave primaria para as tabelas implicadas nas bases remota e local. Pode criar esta chave via o editor de estrutura ou os comandos de SQL. Caso não foi especificado a chave primária, a opção está em cinza.