download.4d.comdownload.4d.com/documents/products_documentation/lastversion… · tutorial...

Manual de SQL

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

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

Introdução

O SQL (Structured Query Language) é uma ferramenta de criação, organização, gestão e recuperação de dados armazenadosem um banco de dados do computador. SQL não é um sistema de gerenciamento de banco de dados, ou um produtoindependente, no entanto, SQL é uma parte integral de um sistema de gestão do banco de dados, uma língua e uma ferramentautilizada 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 dentrodo código 4D, como recuperar dados usando comandos SQL, como passar parâmetros e como obter resultados depois de umaconsulta SQL.

Descrição 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 dadosde exemplo chamado "4D SQL Code Samples" que pode baixar de nosso servidor ftp. (ftp://ftp-public.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 oID 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 podeacessar selecionando o comando de menu Demo SQL>Show samples:

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ódigoseria:

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 eEnd 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 ossí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 umavariá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). Apesquisa simples se converte em:

C_LONGINT($AllMovies) $AllMovies:=0 ` Inicializa uma conexão com o motor SQL interno

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 simplesse 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 myTableWHERE <SQL_Fórmula>

myTable é o nome da tabela passada no primeiro parâmetro e SQL_Formula é o texto da pesquisa passado comosegundo 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 MOVIESWHERE ID <> 0

A quarta forma de interagir com o motor SQL é utilizar o comando SQL dinâmico EXECUTE IMMEDIATE. O código seconverte 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 emmodo 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 dajanela, pode escolher o modo de interrogação do motor de 4D:

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

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

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 janelaprincipal. Escolha o modo de interrogação do motor de 4D e faça clique no botão WHERE clause.

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 filmeslanç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 TOARRAY([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 deparâmetros.O resultado da pesquisa SQL é guardada nos arrays aMovieYear, aTitles, aDirectories, aMedias e aSoldTickets. Osresultados 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)

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))


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 TOARRAY([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))


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 deconsulta e pressione o botão SQL query results in arrays.

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 setentar comparar números com cadeias de caracteres. Neste contexto, a expressão CAST é muito importante, especialmentequando utiliza SQL dentro de uma linguagem de programação cujos tipos de dados não coincidem com os tipos suportados pelopadrão SQL. Você vai encontrar a continuação a pesquisa da seção modificada ligeiramente para poder utilizar a expressãoCAST.

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 TOARRAY([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))


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))


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)"

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))


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 TOARRAY([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))


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 omodo de consulta e pressione o botão Using CAST.

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 obterinformação adicional, como o ano, título, diretor, os meios utilizados e boletos vendidos. O resultado deve ser organizado por ano.


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 TOARRAY([MOVIES]Year_of_Movie;aMovieYear;[MOVIES]Title;aTitles;[MOVIES]Director;aDirectors; [MOVIES]Media;aMedias;[MOVIES]Sold_Tickets;aSoldTickets) SORT ARRAY(aMovieYear;aTitles;aDirectors;aMedias;>)


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


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:=""

$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


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 TOARRAY([MOVIES]Year_of_Movie;aMovieYear;[MOVIES]Title;aTitles;[MOVIES]Director;aDirectors; [MOVIES]Media;aMedias;[MOVIES]Sold_Tickets;aSoldTickets) SORT ARRAY(aMovieYear;aTitles;aDirectors;aMedias;>)


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, podeescolher o modo de pesquisa e pressionar o botão ORDER BY clause.

Utilizar a cláusula GROUP BY

Queremos obter informação sobre o número anual total de entradas vendidas desde 1979. O resultado será ordenado por ano.


` 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))


` 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))


` 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))


` 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))


` Using dynamic SQL by EXECUTE IMMEDIATE C_TEXT($tQueryTxt) ARRAY LONGINT(aSoldTickets;0) ARRAY INTEGER(aMovieYear;0) C_LONGINT($MovieYear) $MovieYear:=1979 $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" $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, podeescolher o modo de pesquisa e pressionar o botão GROUP BY clause.

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 vendidoscada 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.


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)


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)


C_LONGINT($vMin;$vMax;$vSum) C_REAL($vAverage)

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, podeescolher o modo de pesquisa e pressionar o botão Using Aggregate functions.

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 de10,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 deboletos vendidos seja maior a 10,000,000, e depois ordenar o resultado por ano.


ARRAY INTEGER(aMovieYear;0) ARRAY LONGINT(aSoldTickets;0) C_LONGINT($MovieYear;$vCrtMovieYear;$i;$MinSoldTickets;$vInd) REDUCE SELECTION([MOVIES];0) $MovieYear:=1979 $MinSoldTickets:=10000000 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))


ARRAY INTEGER(aMovieYear;0) ARRAY LONGINT(aSoldTickets;0) C_LONGINT($MovieYear;$MinSoldTickets) $MovieYear:=1979 $MinSoldTickets:=10000000 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 ` 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))


C_TEXT($tQueryTxt) ARRAY INTEGER(aMovieYear;0) ARRAY LONGINT(aSoldTickets;0) C_LONGINT($MovieYear;$MinSoldTickets) $MovieYear:=1979 $MinSoldTickets:=10000000 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))


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:=10000000 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)

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))


C_TEXT($tQueryTxt) ARRAY INTEGER(aMovieYear;0) ARRAY LONGINT(aSoldTickets;0) C_LONGINT($MovieYear;$MinSoldTickets) $MovieYear:=1979 $MinSoldTickets:=10000000 $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, podeescolher o modo de pesquisa e pressionar o botão HAVING clause.

Chamar os métodos 4D desde o código SQL

Agora queremos realizar pesquisas relativas aos atores de cada filme: especificamente, estamos interessados em encontrartodas 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])


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;>)


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

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}


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, {fnFind_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


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

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;>)


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, {fnFind_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, podeescolher o modo de pesquisa e pressionar o botão Calling 4D methods.

Joins

Agora queremos conhecer a cidade de nascimento de cada ator. A lista de atores está na tabela ACTORS e a lista de cidades natabela CITIES. Para executar esta pesquisa necessitamos unir as duas tabelas: ACTORS e CITIES.


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)


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))


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"

$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 deuma tabela como primeiro parâmetro.


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, podeescolher o modo de pesquisa e pressionar o botão Joins.

Utilizar Alias

Se uma pesquisa SQL é muito complexa e contém nomes grandes que dificultam a leitura, é possível utilizar alias para melhorarsua legibilidade. Este é o exemplo anterior utilizando dois alias: Act para a tabela ACTORS e Cit para a tabela CITIES.


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)


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))


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" $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 deuma tabela como primeiro parâmetro.


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 deconsulta e pressione o botão Using Aliases.

Subconsultas

Agora queremos obter uma informação estatística sobre os ingressos vendidos: quais são os filmes cujos boletos vendidos sãosuperiores a média de ingressos vendidos para todas os filmes. Para executar esta pesquisa em SQL, utilizaremos umapesquisa em uma pesquisa, em outras palavras uma subconsulta.


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;>)


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;>)


ARRAY LONGINT(aSoldTickets;0) ARRAY TEXT(aTitles;0) C_TEXT($tQueryTxt) SQL LOGIN(SQL_INTERNAL;"";"") $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" 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;>)


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;>)


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 deconsulta e pressione o botão Subqueries.

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 ecorrigir qualquer erro ou chamando ao comando ON ERR CALL para capturar o erro e tomar as medidas adequadas. Podemosutilizar 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:=10000000 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 eo 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 obotão Detalhes.Para provar o exemplo anterior, na janela principal da base "4D SQL Code Samples", pressione o botão Depurar o códigoSQL.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.

ARRAY LONGINT(aSoldTickets;0) ARRAY INTEGER(aMovieYear;0) C_LONGINT($MovieYear;$MinSoldTickets;MySQL_Error) $MovieYear:=1979 $MinSoldTickets:=10000000 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 ERRCALL.

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', '01446677888'); 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 umamensagem de erro dizendo que a tabela já existe.

Conexões Externas

4D permite o uso do banco de dados externos, ou seja executar consultas SQL em outras bases diferentes da base local. Paraisso, 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 namá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, edepois 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.

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. Paramaior informação, consulte a descrição do comando SQL LOGIN.

1. Duplique a base de exemplo que vem com este tutorial2. 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ódigodeste 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 conectamosa outra base 4D via o driver ODBC e fazemos a mesma consulta. O resultado deve ser o mesmo, é claro.

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 paraacessar ao motor SQL integrado, assim como as diferentes formas de executar pesquisas e recuperar dados. Também detalha aconfiguraçã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

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 de4D. Simplesmente deve inserir a consulta SQL entre as etiquetas: Begin SQL e End SQL. O código entre estas etiquetasnão será analisado pelo intérprete de 4D e será executado pelo motor SQL (ou por outro motor, é definido pelo comandoSQL 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áusulasWHERE 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:

C_STRING(80;vNome) vNome:=Request("Nome:") SQL EXECUTE("SELECT age FROM PEOPLE WHERE nome=<<vNome>>")

ou:

C_STRING(80;vNome) vNome:=Request("Nome:") Begin SQL SELECT age FROM PEOPLE WHERE name= :vNome End SQL

Notas:

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 certascondições:

Pode utilizar variáveis locais dentro de uma sequência Begin SQL / End SQL, exceto com o comando EXECUTEIMMEDIATE;Pode utilizar variáveis locais com o comando SQL EXECUTE quando estas variáveis se utilizam diretamente no parâmetrode 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)

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áusulaINTO 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 qualquerexpressã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 registrosdeverã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ó passodevemos 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 elementoarmazena 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 natabela 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)

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 campoAno_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 consultasSELECT 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ãocalculadas 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 WHEREnomeCompleto=CONCAT(<<vSobrenome>>,<<vNome>>)")

... a função CONCAT(<<vSobrenome>>,<<vNome>>) é chamada para cada registro da tabela, ou seja, a expressão é avaliadapara cada registro.

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 eas aplicações 4D, este acesso é realizado mediante um driver ODBC 4D. Também é possível realizar conexões diretas entreuma 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 rendimentoe segurança, pode especificar a porta TCP e o endereço IP de escuta e restringir as possibilidades de acesso ao banco dedados 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çãocliente 4D conectado a 4D Server). Isto se resume no seguinte diagrama:

Em azul: conexões via ODBCEm vermelho: conexões diretasA nível de pesquisas, a abertura de uma conexão externa ou via ODBC é levada a cabo utilizando o comando SQL LOGIN. Paramaior 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 tipoExcel®, outros DBMS, etc.) ou qualquer outra aplicação 4D se conecta ao servidor SQL de 4D. O driver ODBC 4D deve serinstalado 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 outrasaplicações 4D. Da mesma forma, só as aplicações 4D de gama "Profissional" podem abrir uma conexão direta a outraaplicação 4D. Durante uma conexão direta, a troca de dados é realizada automaticamente em modo síncrono, que eliminaas 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õesdiretas, 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. Aprincipal 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ção4D:

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.

Automaticamente ao inicio da aplicação, via as Propriedades da base. Para fazer isso, mostre a página SQL e selecione aopçã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ívelpara 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áginaSQL 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 19812. Se esta porta já está sendoutilizada por outro serviço, ou se seus parâmetros de conexão requerem outra configuração, pode modificar a porta TCPutilizada pelo servidor SQL de 4D.Nota: - se digitar 0, 4D utilizará o número de porta TCP como padrão, ou seja, 19812.- Pode definir este valor por programação utilizando o seletor SQL Server Port ID do comando SET DATABASEPARAMETER.Endereço IP: permite definir o endereço IP da máquina na qual o servidor SQL deve processar as consultas SQL. Comopadrã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 é selecionadauma 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 estarcorretamente 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 asconexões IPv6 ou IPv4 quando a configuração "Endereço IP" de escuta do servidor é Todas. Para obter maisinformação, consulte a seção Suporte de IPv6.

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 servidorSQL 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 elementospersonalizados: 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 Playerpelo servidor SQL de 4D. Este mecanismo é baseado na presença de um arquivo, chamado "socketpolicy.xml," na pastapreferências do banco (Preferencias/SQL/Flash/). Este arquivo é pedido pelo Flash Player para permitir conexões entredomí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 utilizandoa opção Autorizar as requisições Flash Player: ao ativar esta opção, as requisições Flash Player são aceitas e umarquivo "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 ocomando 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 nobanco 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 aomotor SQL de 4D.Os parâmetros definidos nesta caixa de diálogo são aplicados ao esquema (Schema) como padrão. O controle dos acessosexternos ao banco se baseiam no conceito de esquemas SQL (ver a seção Princípios para Integração 4D e motor SQL de4D). Se não criar esquemas personalizados, o esquema padrão inclui todas as tabelas do banco. Se criar outros esquemas comos direitos de acesso específicos e os associa com as tabelas, o esquema por padrão somente incluirá as tabelas que não estãoincluí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á permitidoadicionar, 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 debanco, 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 tabelasdo 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 suaorigem. Este parâmetro pode ser utilizado mesmo quando o sistema de gestão de acesso por senhas de 4D não estiverativo.<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. Estaopção requer que a gestão de senhas de 4D esteja ativada. O usuário que realiza as consultas dá seu nome e senhadurante 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 tipode acesso Só leitura a um grupo este não terá nenhum efeito já que este grupo, assim como também todos os outros vãocontinuar se beneficiando do acesso Leitura/escritura (atribuído a <Todo o mundo> de forma pré determinada). Com o propósitode 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, osistema 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 maisinformação, consulte o parágrafo "Opção Disponível através SQL" da seção .

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ãodisponí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úmeromáximo de tabelas, colunas (campos) e registros por base, assim como as regras para dar nomes as tabelas e colunas, são asmesmas 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: 32767.Número máximo de colunas (campos) por tabela: teoricamente dois bilhões de colunas (campos), mas por razões decompatibilidade com 4D: 32767.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) chavesprimá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 4DSQL Descrição 4D

Varchar Texto Alfanumérico Texto ou AlfaReal Número de ponto flutuante no faixa de +/-1.7E308 RealNumeric Número entre +/- 2E64 Inteiro 64 bitsFloat Número de ponto flutuante (virtualmente infinito) FloatSmallint Número entre -32 768 e 32 767 InteiroInt Número entre -2 147 483 648 e 2 147 483 647 Inteiro longo, InteiroInt64 Número entre +/- 2E64 Inteiro 64 bits

UUID Número de 16 bytes (128 bits) contém 32 caractereshexadecimais Alpha format UUID

Bit Campo que só aceita os valores TRUE/FALSE ou 1/0 BooleanoBoolean Campo que só aceita os valores TRUE/FALSE ou 1/0 Booleano

Blob Hasta 2 GB; todo objeto binário tal como uma imagem, umdocumento, uma aplicação Blob

Bit varying Até 2 GB; todo objeto binário tal como uma imagem, umdocumento, 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'HH:MM:SS:ZZ'

Partes Data e Hora gerados separadamente(conversão automática)

Duration Duração em formato 'HH:MM:SS:ZZ' HoraInterval Duração em formato 'HH:MM:SS:ZZ' HoraPicture 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 queconverterão os valores de um tipo a outro.

Os seguintes tipos de dados SQL não são implementados:

NCHARNCHAR 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ãosão suportados na linguagem 4D. No entanto, é possível ler e escrever valores NULL em um campo 4D utilizando os comandos Isfield 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 converteautomaticamente 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: 0Para o tipo Data: "00/00/00"Para o tipo Hora: "00:00:00"Para o tipo Booleano: FalsoPara o tipo Imagem: Imagem vaziaPara 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 quearmazenem o valor NULL e vice-versa. Quando os dois tipos de valores (valores por padrão e NULL) estão presentes nosregistros 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 valoresNULOS a valores vazios. Esta opção, que é encontrada na janela Inspetor de campos do editor de estrutura, permite estender oprincípio de utilizar os valores por padrão em todos os tratamentos. Os campos que contenham valores NULL se consideramsistematicamente 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 dedados. 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. Estapropriedade 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 alinguagem 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íveldo motor do banco de dados.Se um campo com este atributo recebe um valor NULL, é gerado um erro.

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ênciasde constantes data e hora ODBC:

{constant_type 'value'}

tipo_constante valor Descriçãod aaaa-mm-dd Data unicamentet hh:mm:ss[.fff] Hora unicamentets aaaa-mm-dd hh:mm:ss[.fff] Data e hora (timestamp)

Note: fff indica milissegundos.Por exemplo, pode utilizar as seguintes constantes:

{ d '2013-10-02' } { t '13:33:41' }{ ts '1998-05-02 01: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á selecionadapor 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 amenos 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ódigoSQL 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 Propriedadesda 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 modoauto-commit é preservar a integridade referencial dos dados. Quando esta opção estiver selecionada, toda pesquisaSELECT, INSERT, UPDATE e DELETE (SIUD) não realizada dentro de uma transação se inclui automaticamente em umaoperação ad hoc. Isso garante que as consultas se executarão em sua totalidade ou em caso de erro, se cancelarãototalmente.

As consultas incluídas em uma transação (gestão personalizada da integridade referencial) não se verão afetadas por estaopçã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 dasconexõ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çãopermite modificar a sensibilidade às maiúsculas e minúsculas dos caracteres nas consultas SQL. Está selecionada comopadrã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 queas comparações de cadeias de caracteres não sejam sensíveis às maiúsculas ("ABC" = "Abc"). Para isso, apenas devedesmarcar 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ósitodos esquemas é atribuir direitos de acesso específicos aos diferentes conjuntos de objetos da base. Os esquemas dividem abase em entidades independentes que em conjunto formam toda a base. Em outras palavras, uma tabela sempre pertence a umsó esquema.

Para criar um esquema, deve utilizar o comando CREATE SCHEMA. A continuação, pode utilizar os comandos GRANT eREVOKE 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émpode usar o menu pop-up "Esquemas" do Inspetor do editor de estrutura de 4D, que lista todos os esquemas definidos nabase: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 em4D 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 demaneira única os registros (linhas). A definição de uma chave primária é particularmente necessária para a função de replicaçãodos 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 SQLUtilizando 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 modificaruma coluna (via o comando ALTER TABLE). A chave primária se define utilizando a cláusula PRIMARY KEY seguida pelo nomeda 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:

Os campos incluídos na chave primária aparecem sublinhados no editor e sua descrição SQL mostra a palavra chave PRIMARYKEY.

Ele ou os campo(s) que pertence(m) a chave primária não deve conter valores duplicados. Se já existem valores duplicados nosregistros 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 menucontextual:

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 devárias tabelas das bases de dados. Uma vez que se define uma vista, pode utilizar em uma instrução SELECT como uma tabelareal.

Os dados se encontram em uma vista se definem mediante uma petição de definição baseada no comando SELECT. As tabelasreais utilizadas na consulta de definição são chamadas "tabelas fontes". Uma vista SQL contém colunas e linhas como uma tabelaestandarte, 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.

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 destastabelas e seus campos:

_USER_TABLES Descreve as tabelas usuário da baseTABLE_NAME VARCHAR Nome de tabelaTEMPORARY BOOLEAN True se a tabela é temporal; caso contrário, falseTABLE_ID INT64 Número de tabelaSCHEMA_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 baseTABLE_NAME VARCHAR Nome de tabelaCOLUMN_NAME VARCHAR Nome de colunaDATA_TYPE INT32 Tipo de colunaDATA_LENGTH INT32 Largo da colunaNULLABLE BOOLEAN True se a coluna aceita valores NULL; caso contrário, falseTABLE_ID INT64 Número de tabelaCOLUMN_ID INT64 Número de coluna

UNIQUENESSBOOLEANTrue se a coluna se declara única; caso contrário, FalseAUTOGENERATEBOOLEANTrue se o valor da coluna é gerado automaticamente para cada novo registro; caso contrário, FalseAUTOINCREMENTBOOLEANTrue se o valor da coluna se incrementa automaticamente; caso contrário, FalseREST_AVAILABLEBOOLEANTrue se a coluna está exposta com o serviço REST; caso contrário, False[#/table]

_USER_INDEXES Descreve os índices usuários da baseINDEX_ID VARCHAR Número de índiceINDEX_NAME VARCHAR Nome de índiceINDEX_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, FalseTABLE_NAME VARCHAR Nome da tabela com índiceUNIQUENESS BOOLEAN True se o índice impõe uma restrição de singularidade; caso contrário, falseTABLE_ID INT64 Número de tabela com índice

_USER_IND_COLUMNS Descreve as colunas de índices usuários da baseINDEX_ID VARCHAR Número de índiceINDEX_NAME VARCHAR Nome de índiceTABLE_NAME VARCHAR Nome de tabela com índiceCOLUMN_NAME VARCHAR Nome de coluna com índiceCOLUMN_POSITION INT32 Posição de coluna no índiceTABLE_ID INT64 Número de tabela com índiceCOLUMN_ID INT64 Número de coluna

_USER_CONSTRAINTS Descreve as restrições usuários da baseCONSTRAINT_ID VARCHAR Número de restriçãoCONSTRAINT_NAME VARCHAR Nome de restriçãoCONSTRAINT_TYPE VARCHAR Tipo de restriçãoTABLE_NAME VARCHAR Nome de tabela com restriçãoTABLE_ID INT64 Número de tabela com restriçãoDELETE_RULE VARCHAR Regra de supressão – CASCADE ou RESTRICTRELATED_TABLE_NAME VARCHAR Nome de tabela relacionadaRELATED_TABLE_ID INT64 Número de tabela relacionada

_USER_CONS_COLUMNS Descreve as colunas de restrições usuários da baseCONSTRAINT_ID VARCHAR Número de restriçãoCONSTRAINT_NAME VARCHAR Nome de restriçãoTABLE_NAME VARCHAR Nome de tabela com restriçãoTABLE_ID INT64 Número de tabela com restriçãoCOLUMN_NAME VARCHAR Nome de coluna com restriçãoCOLUMN_ID INT64 Número de coluna com restriçãoCOLUMN_POSITION INT32 Posição de coluna com restriçãoRELATED_COLUMN_NAME VARCHAR Nome de coluna relacionada em uma restriçãoRELATED_COLUMN_ID INT32 Número de coluna relacionada em uma restrição

_USER_SCHEMAS Descreve os esquemas da baseSCHEMA_ID INT32 Número do esquemaSCHEMA_NAME VARCHAR Nome do esquemaREAD_GROUP_ID INT32 Número do grupo com acesso só a leituraREAD_GROUP_NAME VARCHAR Nome do grupo com acesso a leitura-escrituraREAD_WRITE_GROUP_ID INT32 Número do grupo com acesso a leitura-escrituraREAD_WRITE_GROUP_NAME VARCHAR Nome do grupo having read-write accessALL_GROUP_ID INT32 Número do grupo com acesso completoALL_GROUP_NAME VARCHAR Nome do grupo com acesso completo

_USER_VIEWS Descreve as vistas dos usuários da baseVIEW_NAME VARCHAR Nome de vistaSCHEMA_ID INT32 ID do nom_schema ao qual pertence a vista

_USER_VIEW_COLUMNS Descreve as colunas das vistas dos usuários da baseVIEW_NAME VARCHAR Nome de vistaCOLUMN_NAME VARCHAR Nome de colunaDATA_TYPE INT32 Tipo de colunaDATA_LENGTH INT32 Tamanho de colunaNULLABLE 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 sermodificado ou apagado. Não aparece na lista de esquemas mostrada no inspetor de tabelas. É acessível em modo leituraunicamente por todos os usuários.

Replicação via SQL

4D oferece um mecanismo que permite replicar ou sincronizar os dados de duas ou mais bases 4D via SQL. Esta funcionalidadeespecí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. Asatualizações serão levadas a cabo periodicamente pela base local que recupera os dados da base remota. A replicação é levadaa 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 dabase local, o comando SQL REPLICATE permite recuperar dados de uma tabela da base remota e depois integrar estes dadosem 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. Estescampos são chamados "virtuais" para os diferenciar dos "clássicos" porque têm propriedades específicas: preenchemautomaticamente, pode ser lido mas não modificado pelos usuários e não aparecem nas tabelas sistema da base. A seguintetabela 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 excetoREPLICATE 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 oumodificação, 2 = Supressão

Unicamente com o comando REPLICATEou SYNCHRONIZE

Quando os mecanismos de replicação estão ativos, logo como um registro é criado, modifica ou elimina, a informaçãocorrespondente é 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 remotae 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 umabase 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 tabelaAtivar 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 implicadasnas bases remota e local. Pode criar esta chave via o editor de estrutura ou os comandos de SQL. Caso não foi especificado achave primária, a opção está em cinza.

Quando esta opção está ativa, 4D gera a informação necessária para replicar os registros da tabela (baseada em particular nachave primária da tabela). Esta informação é armazenada nos campos virtuais __ROW_STAMP e __ROW_ACTION.Nota: É possível ativar e desativar a geração de informação de replicação via os comandos SQL CREATE TABLE e ALTERTABLE, utilizando as palavras chaves ENABLE REPLICATE e DISABLE REPLICATE. Para maior informação, consulte adescrição destes comandos.ATENÇÃO: Selecionar esta opção provoca a publicação da informação necessária pelos mecanismos de replicação. Por razõesde segurança, o acesso a esta informação deve estar protegido, assim como deve estar protegido o acesso a seus dadosquando são publicados. Portanto, quando implemente um sistema de replicação utilizando esta opção, deve ter certeza de:• Se o servidor SQL é lançado, o acesso está protegido utilizando as senhas 4D e/ou os esquemas SQL (ver Configuração doservidor SQL de 4D),• Se o servidor HTTP é lançado, o acesso está protegido utilizando as senhas 4D e/ou os esquemas SQL (ver Configuraçãodo servidor SQL de 4D) e/ou do e/ou da definição de uma estrutura virtual via os comandos SET TABLE TITLES e SET FIELDTITLES. Para maior informação, consulte o parágrafo "URL 4DSYNC/" na seção MissingRef.

Atualização da base local

Uma vez que o mecanismo de replicação está ativo em cada tabela de cada base, pode utilizá-lo desde a base local via ocomando SQL REPLICATE. Para maior informação, consulte a descrição deste comando.

Suporte de joins

O motor SQL de 4D amplia o suporte das sentenças join.

As sentenças join podem ser internas ou externas, implícitas ou explícitas. As joins internas (INNER joins) implícitas sãosuportadas pelo comando SELECT. Também pode gerar joins internas e externas explícitas utilizando a palavra chave SQL JOIN.

Nota: A implementação atual de joins no motor SQL de 4D não inclui:

joins naturais.o construtor USING nas joins internas.

Apresentação

As sentenças join permitem fazer conexões entre os registros de duas ou mais tabelas e combinar o resultado em uma tabelanova, chamada join.

Gere joins via as instruções SELECT que especificam as condições de join. Com as joins explícitas, estas condições podem sercomplexas, mas sempre devem ser baseadas em uma comparação de igualdade entre as colunas incluídas na join. Por exemplo,não é possível utilizar o operador >= em uma condição de join explícita. Todo tipo de comparação pode ser utilizada em uma joinimplícita.Internamente, as comparações de igualdade são realizadas diretamente pelo motor de 4D, que garante uma rápida execução.

Nota: Geralmente, no motor do banco de dados, a ordem das tabelas está determinada pela ordem definida durante a pesquisa.No entanto, ao usar combinações, a ordem das tabelas são determinadas pela lista de tabelas. No seguinte exemplo:SELECT * FROM T1 RIGHT OUTER JOIN T2 ON = T2.depID T1.depID;... a ordem das tabelas é T1 e depois T2 (tal como aparecem na lista de tabelas) e não T1 e depois T2 (tal como aparecem nacondição de join).

Joins internas explícitas

Uma join interna (inner join) está baseada em uma comparação de igualdade entre duas colunas. Por exemplo, se consideramosas seguintes três tabelas:

Employeesname depID cityIDAlan 10 30Anne 11 39Bernard 10 33Mark 12 35Martin 15 30Philip NULL 33Thomas 10 NULL

DepartmentsdepID depName10 Program11 EngineeringNULL Marketing12 Development13 Quality

CitiescityID cityName30 Paris33 New YorkNULL Berlin

Nota: Esta estrutura de exemplo será utilizada durante este capítulo.

Este é um exemplo de join interna explícita:

SELECT * FROM employees, departments WHERE employees.DepID = departments.DepID;

Em 4D, pode também utilizar a palavra chave JOIN para especificar uma join interna explícita:

SELECT * FROM employees INNER JOIN departments ON employees.DepID = departments.DepID;

Esta pesquisa pode ser inserida no código 4D da seguinte forma:

ARRAY TEXT(aName;0) ARRAY TEXT(aDepName;0) ARRAY INTEGER(aEmpDepID;0 ARRAY INTEGER(aDepID;0) Begin SQL SELECT * FROM employees INNER JOIN departments ON employees.depID = departments.depID INTO :aName, :aEmpDepID, :aDepID, :aDepName; End SQL

Este é o resultado desta join:aName aEmpDepID aDepID aDepNameAlan 10 10 ProgramAnne 11 11 EngineeringBernard 10 10 ProgramMark 12 12 DevelopmentThomas 10 10 Program

Note que nem os empregados Philip ou Martin nem os departamentos Marketing ou Quality aparecem na join resultante porque:

Philip não tem um departamento associado com seu nome (valor NULL),O ID de departamento de Martin não existe na tabela Departamentos,Não há empregado associado ao departamento de ID 13,O departamento de Marketing não tem um ID associado (valor NULL).

Joins cruzadas (cross) Uma join interna na qual a cláusula WHERE e a cláusula ON são omitidas, se chamam join cruzada ou cartesiana. Realizar umajoin cruzada consiste em associar cada linha de uma tabela a cada linha de outra tabela. O resultado de uma join cruzada é o produto cartesiano das tabelas, com a x b linhas, onde a é o número de linhas da primeiratabela e b é o número de linhas da segunda tabela. Este produto representa todas as combinações possíveis formadas pelaconcatenação de linhas de ambas tabelas. Cada uma das seguintes sintaxes são equivalentes:

SELECT * FROM T1 INNER JOIN T2 SELECT * FROM T1, T2 SELECT * FROM T1 CROSS JOIN T2;

Este é um exemplo de código 4D integrando uma join cruzada:

ARRAY TEXT(aName;0) ARRAY TEXT(aDepName;0) ARRAY INTEGER(aEmpDepID;0 ARRAY INTEGER(aDepID;0) Begin SQL SELECT * FROM employees CROSS JOIN departments INTO :aName, :aEmpDepID, :aDepID, :aDepName; End SQL

Resultado desta join com nossa base de exemplo:

aName aEmpDepID aDepID aDepNameAlan 10 10 ProgramAnne 11 10 ProgramBernard 10 10 ProgramMark 12 10 ProgramMartin 15 10 ProgramPhilip NULL 10 ProgramThomas 10 10 ProgramAlan 10 11 EngineeringAnne 11 11 EngineeringBernard 10 11 EngineeringMark 12 11 EngineeringMartin 15 11 EngineeringPhilip NULL 11 EngineeringThomas 10 11 EngineeringAlan 10 NULL MarketingAnne 11 NULL MarketingBernard 10 NULL MarketingMark 12 NULL MarketingMartin 15 NULL MarketingPhilip NULL NULL MarketingThomas 10 NULL MarketingAlan 10 12 DevelopmentAnne 11 12 DevelopmentBernard 10 12 DevelopmentMark 12 12 DevelopmentMartin 15 12 DevelopmentPhilippe NULL 12 DevelopmentThomas 10 12 DevelopmentAlain 10 13 QualityAnne 11 13 QualityBernard 10 13 QualityMark 12 13 QualityMartin 15 13 QualityPhilip NULL 13 QualityThomas 10 13 Quality

Nota: Por razões de rendimento, as joins cruzadas devem ser utilizadas com cuidado.

Joins externas

Agora pode gerar joins externas com 4D (OUTER JOINs). Em uma join externa, não é necessário que tenha uma correspondênciaentre as linhas das tabelas combinadas. A tabela resultante contém todas as linhas das tabelas (ou de pelo menos uma dastabelas combinadas), inclusive se não há linhas correspondentes. Isto significa que toda a informação de uma tabela pode serutilizada, ainda que as linhas não enchem completamente entre as diferentes tabelas unidas.

Há três tipos de joins externas, definidas pelas palavras chaves LEFT, RIGHT e FULL. LEFT e RIGHT se utilizam para indicar atabela (localizada a esquerda ou a direita da palavra chave JOIN) na que todos os dados devem ser processados. FULL indicauma join externa bilateral.

Nota: Somente as joins externas explícitas são suportadas por 4D.

(Left outer joins) O resultado de uma join externa esquerda (ou left join) sempre contém todos os registros da tabela situada a esquerda da palavrachave, inclusive se a condição de join não encontra um registro correspondente na tabela a direita. Isto significa que para cadalinha da tabela da esquerda, onde a pesquisa não encontra nenhuma linha correspondente na tabela da direita, a join vai conter alinha com valores NULL para cada coluna da tabela da direita. Em outras palavras, uma join externa esquerda devolve todas aslinhas da tabela da esquerda, além das da tabela da direita que correspondam a condição de join (ou NULL se nenhumacorresponde). Tenha em conta que se a tabela da direita contém mais de uma linha que corresponde com o predicado da joinpara uma linha da tabela da esquerda, os valores da tabela esquerda serão repetidas para cada linha diferente da tabela direita.Este é um exemplo de código 4D com uma join externa esquerda:

ARRAY TEXT(aName;0)

ARRAY TEXT(aDepName;0) ARRAY INTEGER(aEmpDepID;0 ARRAY INTEGER(aDepID;0) Begin SQL SELECT * FROM employees LEFT OUTER JOIN departments ON employees.DepID = departments.DepID; INTO :aName, :aEmpDepID, :aDepID, :aDepName; End SQL

Este é o resultado desta join com nossa base de exemplo (as linhas adicionais são mostradas em vermelho):aName aEmpDepID aDepID aDepNameAlan 10 10 ProgramAnne 11 11 EngineeringBernard 10 10 ProgramMark 12 12 DevelopmentThomas 10 10 ProgramMartin 15 NULL NULLPhilip NULL NULL NULL

Right outer joins Uma join externa direita é o oposto exato de uma join externa esquerda. Seu resultado sempre contém todos os registros databela localizada a direita da palavra chave JOIN inclusive se a condição join não encontra um registro correspondente na tabelaesquerda. Este é um exemplo de código 4D com uma join externa direita:

ARRAY TEXT(aName;0) ARRAY TEXT(aDepName;0) ARRAY INTEGER(aEmpDepID;0 ARRAY INTEGER(aDepID;0) Begin SQL SELECT * FROM employees RIGHT OUTER JOIN departments ON employees.DepID = departments.DepID; INTO :aName, :aEmpDepID, :aDepID, :aDepName; End SQL

Este é o resultado desta join com nossa base de exemplo (as linhas adicionais estão em vermelho):aName aEmpDepID aDepID aDepNameAlan 10 10 ProgramAnne 11 11 EngineeringBernard 10 10 ProgramMark 12 12 DevelopmentThomas 10 10 ProgramNULL NULL NULL MarketingNULL NULL 13 Quality

Full outer joins Uma join externa bilateral combina os resultados de uma join externa esquerda e de uma join externa direita. A tabela joinresultante contém todos os registros das tabelas esquerda e direita e enche os campos que faltam de cada lado valores NULL. Este é um exemplo de código 4D com uma join externa bilateral:

ARRAY TEXT(aName;0) ARRAY TEXT(aDepName;0) ARRAY INTEGER(aEmpDepID;0 ARRAY INTEGER(aDepID;0) Begin SQL SELECT * FROM employees FULL OUTER JOIN departments ON employees.DepID = departments.DepID; INTO :aName, :aEmpDepID, :aDepID, :aDepName;

End SQL

Este é o resultado desta join com nossa base de exemplo (as linhas adicionais são mostradas em vermelho):aName aEmpDepID aDepID aDepNameAlan 10 10 ProgramAnne 11 11 EngineeringBernard 10 10 ProgramMark 12 12 DevelopmentThomas 10 10 ProgramMartin 15 NULL NULLPhilip NULL NULL NULLNULL NULL NULL MarketingNULL NULL 13 Quality

Joins múltiplas em somente uma petição É possível combinar várias joins na mesma instrução SELECT. Também é possível combinar joins internas implícitas ou explicitase joins externas explícitas.Este é um exemplo de código 4D com joins múltiplas:

ARRAY TEXT(aName;0) ARRAY TEXT(aDepName;0) ARRAY TEXT(aCityName;0) ARRAY INTEGER(aEmpDepID;0 ARRAY INTEGER(aEmpCityID;0) ARRAY INTEGER(aDepID;0) ARRAY INTEGER(aCityID;0) Begin SQL SELECT * FROM (employees RIGHT OUTER JOIN departments ON employees.depID = departments.depID) LEFT OUTER JOIN cities ON employees.cityID = cities.cityID INTO :aName, :aEmpDepID, :aEmpCityID, :aDepID, :aDepName, :aCityID, :aCityName; End SQL

Este é o resultado desta join com nossa base de exemplo:aName aEmpDepID aEmpCityID aDepID aDepName aCityID aCityNameAlan 10 30 10 Program 30 ParisAnne 11 39 11 Engineering 0 Bernard 10 33 10 Program 33 New YorkMark 12 35 12 Development 0Thomas 10 NULL 10 Program 0

Comandos SQL

Comandos SQL SELECT INSERT UPDATE DELETE CREATE DATABASE USE DATABASE ALTER DATABASE CREATE TABLE ALTER TABLE DROP TABLE CREATE INDEX DROP INDEX LOCK TABLE UNLOCK TABLE EXECUTE IMMEDIATE CREATE SCHEMA ALTER SCHEMA DROP SCHEMA CREATE VIEW DROP VIEW GRANT REVOKE REPLICATE SYNCHRONIZE

Comandos SQL

Os comandos SQL geralmente são agrupados em duas categorias:

Comandos de manipulação de dados, que se utilizam para obter, adicionar, tirar e/ou modificar a informação do banco dedados. Especificamente, isto se refere aos comandos SELECT, INSERT, UPDATE e DELETE.Comandos de definição de dados, que se utilizam para criar ou eliminar objetos de estrutura do banco de dados ou asbases de dados. Especificamente, se refere aos comandos CREATE DATABASE, CREATE TABLE, ALTER TABLE,DROP INDEX, DROP TABLE ou CREATE SCHEMA.

Na sintaxe, os nomes e as palavras chaves aparecem em negrito e são passadas "tal qual". Outros elementos aparecem emitálico e são detalhadas no capítulo . As palavras chaves e/ou as cláusulas que são passadas entre colchetes [] são opcionais. Ocaracter barra vertical | separa as diferentes alternativas disponíveis. Quando os elementos são passados entre chaves (),separados por barras verticais, isto indica que só um elemento do conjunto deve ser passado.

SELECT

SELECT [ALL | DISTINCT]

{* | select_elemento, ..., select_elemento}

FROM ref_tabela, ..., ref_tabela

[WHERE critério_pesquisa]

[ORDER BY lista_ordem]

[GROUP BY lista_ordem]

[HAVING critério_pesquisa]

[LIMIT {ref_linguagem_4d|número_inteiro | ALL}]

[OFFSET ref_linguagem_4d|número_inteiro]

[INTO {ref_linguagem_4d, ..., ref_linguagem_4d}]

[FOR UPDATE]

Descrição

O comando SELECT se utiliza para recuperar dados de uma ou mais tabelas.Se passar *, são devolvidas todas as colunas, caso contrário pode passar um ou mais argumentos de tipo select_elemento paraespecificar individualmente cada coluna a recuperar (separados por vírgulas). Se agregar a palavra chave opcional DISTINCT ainstrução SELECT, os valores duplicados não serão devolvidos.Não é possível executar pesquisas que contenham ao mesmo tempo "*" e campos explícitos. Por exemplo, a seguinte instrução:

SELECT *, SALES, TARGET FROM OFFICES

... não se permite, enquanto:

SELECT * FROM OFFICES

...se permite.A cláusula FROM se utiliza para especificar um ou mais argumentos de tipo ref_tabela para a ou as tabela(s) das quais os dadosvão ser recuperados. Pode passar um nome SQL estandarte ou uma cadeia. Não é possível passar uma expressão de tipopesquisa no lugar de um nome de tabela. Também pode passar a palavra chave opcional AS para atribuir um alias a coluna. Sepassar esta palavra chave, deve estar seguida pelo nome do alias que também pode ser um nome SQL ou uma cadeia.A cláusula opcional WHERE estabelece as condições que os dados devem cumprir para ser selecionados. Isto é feito passandouma condição_pequisa que é aplicada aos dados recuperados pela cláusula FROM. A expressão condição_pesquisa sempredevolve um valor de tipo booleano.A cláusula opcional ORDER BY pode ser utilizada para aplicar um critério lista_ordem aos dados selecionados. Também podeadicionar a palavra chave ASC ou DESC para especificar se deseja ordenar de forma ascendente ou descendente. Por padrão,é aplicada a ordem ascendente.A cláusula opcional GROUP BY pode ser utilizada para agrupar dados idênticos em função dos critérios passados emlista_ordem. Pode passar várias colunas de grupo. Esta cláusula pode ser utilizada para evitar redundâncias ou calcular umafunção de adição (SUM, COUNT, MIN ou MAX) que serão aplicados a estes grupos. Também pode agregar a palavra chaveASC ou DESC como com a cláusula ORDER BY.A cláusula opcional HAVING pode ser utilizado para aplicar um critério_pesquisa a um dos grupos. A cláusula HAVING pode serpassada sem uma cláusula GROUP BY.

A cláusula LIMIT opcional permite restringir o número de dados devolvidos a quantidade definida pela variável ref_linguagem_4dou o número_inteiro.

A cláusula opcional OFFSET permite definir um número (variável ref_linguagem_4d ou número_inteiro) de valores a ignorarantes de começar a contar para a aplicação da cláusula LIMIT.

A cláusula INTO permite indicar as variáveis ref_linguagem_4d as quais os dados serão atribuídos.

Um comando SELECT que especifica uma cláusula FOR UPDATE tenta bloquear para escritura todos os registrosselecionados. Se ao menos um registro não pode ser bloqueado, todo o comando falha e é devolvido um erro. No entanto, setodos os registros selecionados estavam bloqueados, então serão mantidos bloqueados até que a transação atual sejaconfirmada ou cancelada.

Exemplo 1

Vamos supor que tenha um banco de dados de filmes com uma tabela que contém os títulos dos filmes, o ano em que foramlançadas e os ingressos vendidos.Gostaríamos de obter os anos a partir de 1979 e a quantidade de entradas vendidas pelos filmes que venderam no total menosde 10 milhões de ingressos. Queremos pular os primeiros 5 anos e mostrar só 10 anos, ordenados por ano.

C_LONGINT($MovieYear;$MinTicketsSold;$StartYear;$EndYear) ARRAY INTEGER(aMovieYear;0) ARRAY LONGINT(aTicketsSold;0) $MovieYear:=1979 $MinTicketsSold:=10000000 $StartYear:=5 $EndYear:=10 Begin SQL SELECT Year_of_Movie, SUM(Tickets_Sold) FROM MOVIES WHERE Year_of_Movie >= :$MovieYear GROUP BY Year_of_Movie HAVING SUM(Tickets_Sold) < :$MinTicketsSold ORDER BY 1 LIMIT :$EndYear OFFSET :$StartYear INTO :aMovieYear, :aTicketsSold; End SQL

Exemplo 2

Este exemplo utiliza uma combinação de critérios de pesquisa:

SELECT supplier_idFROM suppliersWHERE (name = 'CANON')OR (name = 'Hewlett Packard' AND city = 'New York')OR (name = 'Firewall' AND status = 'Closed' AND city = 'Chicago');

Exemplo 3

Dada a tabela VENDEDORES onde COTA é a quantidade de vendas esperada para um representante de vendas e VENDAS aquantidade de vendas efetivamente realizadas.

ARRAY REAL(arrMin_Values;0) ARRAY REAL(arrMax_Values;0) ARRAY REAL(arrTotal_Values;0) Begin SQL SELECT MIN ( ( VENDAS * 100 ) / COTA ), MAX( (VENDAS * 100 ) / COTA ), SUM( COTA ) - SUM ( VENDAS ) FROM VENDEDORES INTO :arrMin_Values, :arrMax_Values, :arrTotal_Values; End SQL

Exemplo 4

Este exemplo procura todos os atores que nasceram em uma cidade determinada:

ARRAY TEXT(aActorName;0) ARRAY TEXT(aCityName;0) Begin SQL SELECT ACTORS.FirstName, CITIES.City_Name FROM ACTORS AS 'Act', CITIES AS 'Cit' WHERE Act.Birth_City_ID=Cit.City_ID ORDER BY 2 ASC INTO : aActorName, : aCityName; End SQL

INSERT

INSERT INTO {nom_sql | cadeia_sql}[(ref_coluna, ..., ref_coluna)][VALUES({[INFILE]expressão_aritmética |NULL}, ..., {[INFILE]expressão_aritmética |NULL};) |sub_pesquisa]

Descrição

O comando INSERT se utiliza para adicionar dados a uma tabela existente. A tabela aonde os dados são adicionados épassada utilizando um argumento de tipo nom_sql ou cadeia_sql. Os argumentos opcionais tipo ref_coluna permitem definir ascolunas nas quais inserir os valores. Se não passar ref_coluna, os valores serão inseridos na mesma ordem que na base (oprimeiro valor passado será inserido na primeira coluna, o segundo valor na segunda coluna, e assim sucessivamente).A palavra chave VALUES se utiliza para passar ele ou os valor(es) a inserir na(s) coluna(s) especificada(s). Pode passar umaexpressão_aritmética o NULL. Por outra parte, una subconsulta pode ser passada na palavra chave VALUES com o propósitode inserir uma seleção de dados que são passados como os valores.O número de valores passados via a palavra chave VALUES deve coincidir com o número de colunas especificado peloargumento de tipo ref_coluna passado e cada um deles também deve coincidir com o tipo de dados da coluna correspondenteou ao menos ser convertida a esse tipo de dados.A palavra chave INFILE lhe permite utilizar o conteúdo de um arquivo externo para especificar os valores de um novo registro.Esta palavra chave só deve ser utilizada com expressões de tipo VARCHAR. Quando é passada a palavra chave INFILE, o valorexpressão_aritmética é avaliada como uma via do arquivo, e se é encontrado o arquivo, o conteúdo do arquivo é inserido nacoluna correspondente. Só os campos de tipo texto ou BLOB podem receber valores de um INFILE. O conteúdo do arquivo étransferido como dados brutos, sem interpretação.O arquivo procurado deve estar no computador que hospeda o motor SQL, inclusive se a consulta vem de um cliente remoto. Damesma forma, a via deve ser expressada respeitando a sintaxe do sistema operativo do motor de SQL. Pode ser absoluta ourelativa.O comando INSERT é suportado em pesquisas única e multi linhas. No entanto, uma instrução INSERT multi linhas não permiterealizar operações UNION e JOIN.O motor de 4D permite a inserção de valores multi linhas, que podem simplificar e otimizar o código, particularmente, ao introduzirgrandes quantidades de dados. A sintaxe das inserções multi linhas é do tipo:

INSERT INTO {sql_name | sql_string}[(column_ref, ..., column_ref)]VALUES(arithmetic_expression, ..., arithmetic_expression), ..., (arithmetic_expression, ...,arithmetic_expression);

Esta sintaxe é ilustrada nos exemplos 3 e 4.

Exemplo 1

Este exemplo simples permite inserir uma seleção da table2 na table1:

INSERT INTO table1 (SELECT * FROM table2)

Exemplo 2

Este exemplo cria uma tabela e depois insere os valores nela:

CREATE TABLE ACTOR_FANS(ID INT32, Nom VARCHAR);INSERT INTO ACTOR_FANS(ID, Nom)VALUES (1, 'Francis’);

Exemplo 3

A sintaxe multi linhas permite evitar a repetição tediosa de linhas:

INSERT INTO MiTabla(Campo1,Campo2,CampoBol,CampoHora,CampoInfo)VALUES(1,1,1,'11/01/01','11:01:01',’Primeira linha’),(2,2,0,'12/01/02','12:02:02',’Segunda linha’),(3,3,1,'13/01/03','13:03:03',’Terceira linha’),………(7,7,1,'17/01/07','17:07:07',’Sétima linha’);

Exemplo 4

Também pode utilizar as variáveis ou arrays 4D com a sintaxes multi linhas:

INSERT INTO MinhaTabela(Campo1,Campo2,CampoBool,CampoData,CampoHora, CampoInfo)VALUES( :vArrId, :vArrIdx, :vArrbool, :vArrdate, :vArrL, :vArrText);

Nota: Não é possível combinar as variáveis simples e os arrays na mesma instrução INSERT.

UPDATE

UPDATE {nom_sql| cadeia_sql}SET nom_sql = {expressão_aritmética |NULL}, ..., nom_sql = {expressão_aritmética |NULL}[WHERE critério_pesquisa]

Descrição

O comando UPDATE permite modificar os dados contidos em uma tabela indicada pelo argumento nom_sql ou cadeia_sql.A cláusula SET se utiliza para atribuir novos valores (via uma expressão_aritmética ou o valor NULL).A cláusula opcional WHERE se utiliza para especificar quais dados (os que cumprem a condição critério_pesquisa) devem seratualizados. Se não passar, todos os dados da tabela serão atualizados com os novos valores passados na cláusula SET.O comando UPDATE é suportado para consultas e subconsultas, no entanto, uma instrução UPDATE posicionada não écompatível.As atualizações em cascata são implementadas em 4D, mas as regras de supressão SET NULL e SET DEFAULT não sãosuportadas.

Exemplo

O seguinte exemplo modifica a tabela MOVIES de maneira que os ingressos vendidos para o filme "Air Force One" sejam 3 500000:

UPDATE MOVIESSET Tickets_Sold = 3500000WHERE TITLE = 'Air Force One';

DELETE

DELETE FROM {nom_sql | cadeia_sql}

[WHERE critério_pesquisa]

Description

O comando DELETE pode ser utilizado para suprimir tudo ou uma parte dos dados da tabela indicada pelo argumento nom_sqlou cadeia_sql depois da palavra chave FROM.

A cláusula WHERE opcional se utiliza para indicar que parte dos dados (os que cumprem a condição critério_pesquisa) vão serexcluídos. Se não passar, todos os dados da tabela serão suprimidos.

Não está suportada a instrução DELETE posicionada. As exclusões em cascata são implementadas em 4D, mas as regras desupressão SET DEFAULT e SET NULL não são suportadas.

Example

Este é um exemplo que elimina todas os filme que foram lançados no ano 2000 ou antes da tabela MOVIES:

DELETE FROM MOVIESWHERE Ano_estréia <= 2000;

CREATE DATABASE

CREATE DATABASE [IF NOT EXISTS] DATAFILE <Via de acesso completa>

Descrição

O comando CREATE DATABASE lhe permite criar um novo banco de dados externa (arquivos db .4db e .4dd) em umalocalização específica.

Se passar a restrição IF NOT EXISTS, o banco de dados não é criado e nenhum erro é gerado se uma base com o mesmonome já existe na localização especificada.Se não passar a restrição IF NOT EXISTS, o banco de dados não é criado e é mostrado a mensagem de erro "Este banco dedados já existe. Não pode ser executado o comando CREATE DATABASE." se um banco de dados com o mesmo nome jáexiste na localização especificada. A cláusula DATAFILE permite especificar o nome completo (via de acesso completa + nome) do novo banco de dados externo.Deve passar o nome do arquivo de estrutura. O programa irá adicionar automaticamente a extensão ".4db" ao arquivo se nãoestá e cria o arquivo de dados. A via pode ser expressada em sintaxe POSIX ou na sintaxe do sistema, pode ser absoluta ourelativa ao arquivo de estrutura da base 4D principal.

Sintaxe POSIX (tipo URL): Os nomes das pastas estão separadas por uma barra oblíqua ("/"), independentemente daplataforma que utilize, por exemplo: .../extdatabases/myDB.4dbPara uma via absoluta, passe na primeira posição o nome do volume seguido de dois pontos, por exemplo:"C:/test/extdatabases/myDB.4db"

Sintaxe sistema: Via de acesso respeitando a sintaxe da plataforma atual, por exemplo:(Mac OS) Unidad:Applications:miserv:basesexternas:mibase.4db(Windows) C:ApplicationsmyservextdatabasesmyDB.4db

Depois da execução bem feita do comando CREATE DATABASE, o novo banco de dados criado não se converteautomaticamente no banco atual. Para fazer isto, deve declarar explicitamente como o banco atual com o comando USEDATABASE.

Sobre as bases externas Uma base externa é uma base 4D independente da base 4D principal, mas com a que pode trabalhar desde a base 4D principalutilizando o motor SQL de 4D. Usar uma base externa significa designar temporariamente esta base como base atual, ou seja,como a base de objetivo das consultas SQL executadas por 4D. Por padrão, a base atual é a base principal.

Pode criar um banco de dados externos diretamente desde a base principal com o comando CREATE DATABASE. Uma vezcriado, uma base externa pode ser designada como a base atual com o comando USE DATABASE. A continuação, pode sermodificada através de comandos padrão SQL (CREATE TABLE, ALTER TABLE, etc.) e pode armazenar dados nela. A funçãoDATABASE_PATH permite conhecer o banco de dados atual em qualquer momento.O interesse principal das bases externas reside no fato de que podem ser criadas e manipuladas via componentes 4D. Istopermite o desenvolvimento de componentes que são capazes de criar tabelas e campos de acordo a suas necessidades.

Nota: Uma base externa é uma base 4D padrão. Pode abrir e manipular como a base principal mediante uma aplicação 4D ou4D Server. Pelo contrario, toda base 4D padrão pode ser utilizada como base externa. No entanto, é imperativo que não ative osistema de gestão de acesso (mediante a atribuição de uma senha ao Designer) e uma base externa, caso contrário já nãopoderá ter acesso a ela através do comando USE DATABASE.

Exemplo 1

Criação de arquivos de base externa ExternalDB.4DB e ExternalDB.4DD em C:/MinhaBase/:

Begin SQL CREATE DATABASE IF NOT EXISTS DATAFILE 'C:/MinhaBase/ExternalDB'; End SQL

Exemplo 2

Criação de arquivos de base externa TestDB.4DB e TestDB.4DD junto do arquivo de estrutura da base principal:

Begin SQL CREATE DATABASE IF NOT EXISTS DATAFILE 'TestDB'; End SQL

Exemplo 3

Criação dos arquivos de base externa External.4DB e External.4DD na localização definida pelo usuário:

C_TEXT($path) $path:=Select folder("Pasta de destino da base externa:") $path:=$path+"External" Begin SQL CREATE DATABASE DATAFILE <<$path>>; End SQL

USE DATABASE

USE [LOCAL | REMOTE] DATABASE{DATAFILE <Via de acesso completa> | SQL_INTERNAL | DEFAULT}[AUTO_CLOSE]

Descrição

O comando USE DATABASE se utiliza para designar uma base externa como banco de dados atual, em outras palavras, a basea qual serão direcionadas as próximas consultas SQL no processo atual. Todos os tipos de consultas SQL concernientes:consultas incluídas na estrutura Begin SQL/End SQL, comandos SQL EXECUTE ou EXECUTE SCRIPT, etc.Nota: Para maior informação sobre bases externas, consulte a descrição do comandoCREATE DATABASE.

Se trabalha em uma configuração monopuesto, a base externa deve estar localizada na mesma máquina que seu 4D.Se trabalha em modo remoto, a base externa pode estar localizada na máquina local ou na máquina 4D Server.

Se utiliza 4D em modo remoto, a palavra chave REMOTE permite designar uma base externa localizada em 4D Server.

Por razões de segurança, este mecanismo só funciona com conexões remotas nativas, ou seja, no contexto de uma base 4Dremota conectada a 4D Server. As conexões via ODBC ou pass-through não estão permitidas.Se não é especificada a palavra chave, a opção LOCAL se utiliza por padrão. Se está utilizando 4D em modo local, as palavraschaves REMOTE e LOCAL são ignoradas: as conexões são sempre locais.

Para designar uma base externa a utilizar, passe seu caminho completo (via de acesso + nome) na cláusula DATAFILE. A viapode ser expressada na sintaxe POSIX ou na sintaxe do sistema. Pode ser absoluta ou relativa ao arquivo de estrutura da base4D principal.Em modo remoto, é passada a palavra chave REMOTE, este parâmetro designa a via de acesso da base a partir da máquinaservidor. Se omitida ou se passada a palavra chave LOCAL, este parâmetro designa a via de acesso da base na máquina 4Dlocal.Importante: Deve designar uma base 4D externa válida e na qual o sistema de controle de acesso não esteja ativado (mediantea atribuição de uma senha ao Designer). Caso contrário, é gerado um erro.Com o propósito de restabelecer a base principal como a base atual, execute o comando ao passar a palavra chaveSQL_INTERNAL ou DEFAULT.Passe AUTO_CLOSE se deseja fechar fisicamente a base externa depois de seu uso, ou seja, quando você muda a base atual.De fato, a abertura de uma base externa é uma operação que requer um pouco de tempo, por razões de otimização 4D mantémna memória a informação relativa as bases externas abertas durante a sessão usuário. Esta informação se mantém em memóriaaté que seja lançada a aplicação 4D. As aberturas posteriores da mesma base externa, são portanto mais rápidas. No entanto,isto impede a mudança de bases externas entre várias aplicações 4D porque o banco de dados externo segue aberto emleitura/escritura para a primeira aplicação que a utilize. Se várias aplicações 4D devem utilizar a mesma base externa ao mesmotempo, passe a palavra chave AUTO_CLOSE para liberar fisicamente a base externa depois de seu uso.Esta restrição não aplica aos processos da mesma aplicação: diferentes processos de uma aplicação sempre podem acessar amesma base externa em leitura/escritura sem que seja necessário forçar seu fechamento.Tenha em conta que quando vários processos utilizam a mesma base externa, é fisicamente liberada somente até o últimoprocesso que utiliza o fechamento, inclusive quando é passado a opção AUTO_CLOSE. Deve ter em conta este funcionamentopara as operações que implicam a mudança entre aplicações ou supressão de bases externas.

Exemplo

Uso de uma base externa para uma pesquisa depois retorna a base principal:

Begin SQL USE DATABASE DATAFILE 'C:/MinhaBase/Noms' SELECT Name FROM emp INTO :tNoms1 USE DATABASE SQL_INTERNAL End SQL

ALTER DATABASE

ALTER DATABASE {ENABLE | DISABLE} {INDEXES | CONSTRAINTS | TRIGGERS}

Descrição

O comando ALTER DATABASE ativa ou desabilita as opções SQL da base atual para a sessão atual. Ou seja par todos osusuários e processos até que a base se reinicie.

Este comando está desenhado para permitir desabilitar temporariamente as opções SQL com o propósito de acelerar certasoperações que consumem uma grande quantidade de recursos. Por exemplo, desativar os índices e as restrições antes decomeçar a importação de uma grande quantidade de dados pode reduzir significativamente a duração da importação.Leve em conta que as restrições incluem as chaves primárias e as chaves externas, assim como os atributos de singularidade ede nulidade.

Se preferir gerenciar os triggers individualmente para cada tabela, deve utilizar ALTER TABLE.

Exemplo

Exemplo de uma importação com desativação temporal de todas as opções SQL:

Begin SQL ALTER DATABASE DISABLE INDEXES; ALTER DATABASE DISABLE CONSTRAINTS; ALTER DATABASE DISABLE TRIGGERS; End SQL SQL EXECUTE SCRIPT("C:\\Exported_data\\Export.sql";SQL On error continue) Begin SQL ALTER DATABASE ENABLE INDEXES; ALTER DATABASE ENABLE CONSTRAINTS; ALTER DATABASE ENABLE TRIGGERS; End SQL

CREATE TABLE

CREATE TABLE [IF NOT EXISTS] [nom_sql.]nom_sql({definição_coluna |restrição_tabela}[PRIMARY KEY], ... ,{definição_coluna |restrição_tabela}[PRIMARY KEY]) [{ENABLE | DISABLE} REPLICATE]

Descrição

O comando CREATE TABLE se utiliza para criar uma tabela chamada nom_sql com os campos especificados ao passar umaou mais definição_coluna e/ou restrição_tabela. Se passada a restrição IF NOT EXISTS, a tabela só é criada quando não existeuma tabela com o mesmo nome na base. Caso contrário, não se é criado e não é gerado nenhum erro.

O primeiro parâmetro nom_sql (opcional) permite designar o esquema SQL ao qual quer atribuir a tabela. Se não passa esteparâmetro ou se passar o nome de um esquema que não existe, o esquema por padrão lhe é atribuído automaticamente,chamado "DEFAULT_SCHEMA". Para maior informação sobre os esquemas SQL, consulte a seção Princípios paraIntegração 4D e motor SQL de 4D.

Nota: Também é possível atribuir uma tabela a um esquema SQL utilizando o menu pop-up "Esquemas" no Inspetor de tabelas de4D. Este menu contém a lista de esquemas definidos na base.

Uma definição_coluna contém o nome (nom_sql) e o tipo de dados (tipo_dados_sql) de uma coluna e uma restrição_tabelarestringe os valores que uma tabela pode armazenar.

A palavra chave PRIMARY KEY se utiliza para especificar a chave primária quando é criada a tabela. Para maior informaçãosobre as chaves primárias, consulte a seção Princípios para Integração 4D e motor SQL de 4D. As palavras chaves ENABLE REPLICATE e DISABLE REPLICATE se utilizam para ativar ou desativar o mecanismo quepermite a replicação da tabela (ver a seção Replicação via SQL).

Exemplo 1

Este é um exemplo simples de criação de uma tabela com duas colunas:

CREATE TABLE ACTOR_FANS(ID INT32, Nom VARCHAR);

Exemplo 2

Este exemplo cria a mesma tabela mas só se não há uma tabela com o mesmo nome:

CREATE TABLE IF NOT EXISTS ACTOR_FANS(ID INT32, Nom VARCHAR);

Exemplo 3

Este exemplo cria a tabela "Preferences" e se lhe atribui o esquema "Control":

CREATE TABLE Control.Preferences(ID INT32, Value VARCHAR);

ALTER TABLE

ALTER TABLE nom_sql{ADD [TRAILING] definição_coluna [PRIMARY KEY] |[TRAILING] |DROP nom_sql |ADD definição_chave_primária |DROP PRIMARY KEY |ADD definição_chave_externa |DROP CONSTRAINT nom_sql |[{ENABLE | DISABLE} REPLICATE] |[{ENABLE | DISABLE} LOG] |[{ENABLE | DISABLE} AUTO_INCREMENT] |[{ENABLE | DISABLE} AUTO_GENERATE] |[{ENABLE | DISABLE} TRIGGERS] |SET SCHEMA nom_sql}

Descrição

O comando ALTER TABLE se utiliza para modificar uma tabela existente (nom_sql). Pode realizar uma das seguintes ações:Passar ADD definição_coluna adiciona uma coluna a tabela. A palavra chave TRAILING (deve ser localizada em frente de definicao_coluna se utilizada) força a criação da coluna a criar logoda última coluna existente da tabela no arquivo de estrutura. Esta opção é útil quando as colunas que contém os dados que forameliminados da tabela (sem que os dados sejam apagados), para evitar que os dados existentes sejam atribuídos a nova coluna.A palavra chave PRIMARY KEY se utiliza para definir a chave primária quando é adicionada uma coluna.Passar DROP nom_sql elimina a coluna nom_sql da tabela.Passar ADD definição_chave_primária adiciona uma chave primária (PRIMARY KEY) a tabela.Passar DROP PRIMARY KEY elimina a chave primária (PRIMARY KEY) da tabela.Passar ADD definição_chave_externa adiciona uma chave externa (FOREIGN KEY) a tabela.Passar DROP CONSTRAINT nom_sql elimina a restrição especificada por nom_sql da tabela.Passar ENABLE REPLICATE ou DISABLE REPLICATE ativa ou desativa o mecanismo que permite a replicação da tabela(ver a seção Replicação via SQL).Passar ENABLE LOG ou DISABLE LOG ativa ou desativa o histórico da tabela.Passar ENABLE AUTO_INCREMENT ou DISABLE AUTO_INCREMENT ativa ou desativa a opção "Autoincrement" doscampos de tipo inteiro longo.Passar ENABLE AUTO_GENERATE ou DISABLE AUTO_GENERATE ativa ou desativa a opção "Auto UUID" para os camposalfa de tipo UUID.Pasar ENABLE TRIGGERS ou DISABLE TRIGGERS ativa ou desativa os triggers para a tabela. Se deseja gerenciar ostriggers globalmente a nível da base, deve utilizar ALTER DATABASE.Passar SET SCHEMA nom_sql transfere a tabela ao esquema nom_sql.O comando devolve um erro:

quando o parâmetro opcional ENABLE LOG se passar e nenhuma chave primária válida foi definida,se tentar modificar ou eliminar a definição de chave primária da tabela sem desativar o histórico via DISABLE LOG.

Exemplo

Este exemplo cria uma tabela, insere um conjunto de valores nela, depois adiciona uma coluna Num_Tel, insere outro conjunto devalores e depois elimina a coluna ID:

CREATE TABLE ACTOR_FANS(ID INT32, Nom VARCHAR);

INSERT INTO ACTOR_FANS(ID, Nom)VALUES(1, 'Francis');

ALTER TABLE ACTOR_FANSADD Num_Tel VARCHAR;

INSERT INTO ACTOR_FANS(ID, Nom, Num_Tel)VALUES (2, 'Florence', '01446677888');

ALTER TABLE ACTOR_FANSDROP ID;

DROP TABLE

DROP TABLE [IF EXISTS] sql_name

Descrição

O comando DROP TABLE se utiliza para eliminar a tabela nom_sql de uma base. Quando é passada a restrição IF EXISTS, sea tabela a eliminar não existe na base, o comando não faz nada e não é gerado nenhum erro.

Este comando não só elimina a tabela da estrutura, se não também seus dados e os índices, triggers e restrições associadas.Não pode ser utilizado este comando com uma tabela referenciada por uma restrição FOREIGN KEY.

Nota: Deve estar seguro de que quando se execute o comando DROP TABLE, não tenha registros da tabela nom_sql que seencarreguem em memória em modo de escritura. Caso contrário, é gerado o erro 1272.

Exemplo 1

Este exemplo exclui a tabela ACTOR_FANS:

DROP TABLE ACTOR_FANS

Exemplo 2

Este exemplo faz o mesmo que o anterior exceto que neste caso, se a tabela ACTOR_FANS não existe, não é gerado nenhumerro:

DROP TABLE IF EXISTS ACTOR_FANS

CREATE INDEX

CREATE [UNIQUE] INDEX nom_sql ON nom_sql (ref_coluna, ... , ref_coluna)

Description

O comando CREATE INDEX permite criar um índice (nom_sql) em uma ou mais colunas de uma tabela existente (nom_sql)designada pelo ou os parâmetros ref_coluna. Os índices são transparentes para os usuários e permitem acelerar a execução daspetições.Também pode passar a palavra chave opcional UNIQUE com o propósito de criar um índice que não permite os valoresduplicados.

Example

Este é um exemplo de criação de índices:

CREATE INDEX ID_INDEX ON ACTOR_FANS (ID)

DROP INDEX

DROP INDEX nom_sql

Descrição

O comando DROP INDEX permite eliminar da base o índice existente designado por nom_sql. Não pode ser utilizado com osíndices criados pelas restrições PRIMARY KEY ou UNIQUE.

Exemplo

Este é um exemplo simples de eliminação de um índice:

DROP INDEX ID_INDEX

LOCK TABLE

LOCK TABLE nom_sql IN {EXCLUSIVE | SHARE} MODE

Description

O comando LOCK TABLE permite bloquear a tabela nom_sql no modo EXCLUSIVE ou SHARE.No modo EXCLUSIVE, os dados da tabela não podem ser lidos ou modificados por outra transação.No modo SHARE, os dados da tabela podem ser lidos por outras transações mas as modificações seguem sendo proibidas.

Exemplo

Este exemplo bloqueia a tabela MOVIES de forma que possa ser lida mas não modificada por outras transações:

LOCK TABLE MOVIES IN SHARE MODE

UNLOCK TABLE

UNLOCK TABLE nom_sql

Descrição

O comando UNLOCK TABLE se utiliza para desbloquear a tabela nom_sql previamente bloqueada sob o comando LOCKTABLE. Este comando não funciona se passa dentro de uma transação ou se é utilizado em uma tabela que bloqueada por outroprocesso.

Exemplo

Este comando elimina os blocos da tabela FILMES:

UNLOCK TABLE FILMES

EXECUTE IMMEDIATE

EXECUTE IMMEDIATE <<nom_sql>> | <<$nom_sql>> | :nom_sql | :$nom_sql

Descrição

O comando EXECUTE IMMEDIATE permite executar uma expressão SQL dinâmica. O argumento nom_sql representa umavariável que contém um conjunto de instruções SQL que serão executados como um todo.Notas:

Este comando não pode ser utilizado em uma conexão SQL externa (pass-through) iniciada via o comando 4D USEEXTERNAL DATABASE.Em modo compilado, não é possível utilizar as variáveis 4D locais (que começam pelo caractere $) na cadeia de pesquisapassada ao comando EXECUTE IMMEDIATE.

Exemplo

Este exemplo recupera o número de filmes realizados desde 1960:

C_LONGINT(NumMovies) C_TEXT(tQueryTxt) NumMovies:=0 tQueryTxt:="SELECT COUNT(*) FROM MOVIES WHERE Year_of_Movie >= 1960 INTO :NumMovies;" Begin SQL EXECUTE IMMEDIATE :tQueryTxt; End SQL ALERT("A videoteca contém "+String(NumMovies)+" filmes realizados desde 1960")

CREATE SCHEMA

CREATE SCHEMA nom_sql

Descrição

O comando CREATE SCHEMA permite criar um novo esquema SQL chamado nom_sql no banco de dados. Pode utilizartodo nom_sql exceto por "DEFAULT_SCHEMA" e "SYSTEM_SCHEMA".

Nota: Para maior informação sobre os esquemas, consulte a seção .

Quando é criado um novo esquema, por padrão os direitos de acesso associados são os seguintes:

Só leitura (Dados): <Todos>Leitura/Escritura (Dados):<Todos>Completo (dados e estrutura): <Pessoa>Cada esquema pode atribuir-se um tipo de direitos de acesso externos utilizando o comando GRANT.

Só o Designer e o Administrador da base pode criar, modificar ou eliminar esquemas.Se o sistema de gestão de acesso de 4D não está ativo (em outras palavras, se não lhe foi atribuído senha ao Designer), todosos usuários podem criar e modificar esquemas sem nenhuma restrição.

Quando um banco de dados é criado ou se converte com 4D v11 SQL (desde a versão 3), é criado um esquema por padrão paraagrupar todas as tabelas da base. Este esquema se chama "DEFAULT_SCHEMA". Não pode ser apagado nem renomeado.

Exemplo

Criação de um esquema chamado "Direitos_Contabilidade":

CREATE SCHEMA Direitos_Contabilidade

ALTER SCHEMA

ALTER SCHEMA nom_sql RENAME TO nom_sql

Descrição

O comando ALTER SCHEMA permite renomear o esquema SQL nom_sql (primeiro parâmetro) por nom_sql (segundoparâmetro).Somente o Designer e o Administrador podem modificar esquemas.

Nota: Não é possível renomear o esquema por padrão ("DEFAULT_SCHEMA") ou o esquema que contém as tabelas sistema("SYSTEM_SCHEMA") nem utilizar estes nomes em sql_name (segundo parâmetro).

Exemplo

Renomear o esquema MyFirstSchema por MyLastSchema:

ALTER SCHEMA MyFirstSchema RENAME TO MyLastSchema

DROP SCHEMA

DROP SCHEMA nom_sql

Descrição

O comando DROP SCHEMA pode ser usado para excluir o esquema designado por nom_sql.

É possível excluir qualquer esquema, exceto o esquema por padrão (DEFAULT_SCHEMA) e o esquema que contém astabelas sistema ("SYSTEM_SCHEMA"). Quando é eliminado um esquema, todas as tabelas que lhe foram atribuídas setransferem ao esquema por padrão. As tabelas transferidas herdam os direitos de acesso do esquema por padrão.

Se você tentar excluir um esquema que não existe ou que já foi removido, é gerado um erro.

Somente o Designer e o Administrador da base podem excluir os esquemas.

Exemplo

Você quer excluir o esquema MyFirstSchema (ao qual estão atribuídas as tabelas Table1 e Table2):

DROP SCHEMA MyFirstSchema

Depois desta operação, as duas tabelas Table1 e Table2, serão novamente atribuídas ao esquema por padrão.

CREATE VIEW

CREATE [OR REPLACE] VIEW [schema_name.]view_name [(column_list)] AS select_statement[;]

Descrição

O comando CREATE VIEW permite criar uma vista SQL chamada nom_vista (que é um nom_sql estandarte) que contém ascolunas definidas no parâmetro lista_colunas. É necessário especificar um nome de coluna se esta coluna é uma função ou sederiva de uma operação aritmética (escalar). Também é necessário especificar um nome de coluna quando se quer evitar terdiferentes colunas com o mesmo nome (por exemplo, durante uma operação JOIN) ou quando deseja utilizar um nome de colunadiferente do que se deriva.Se passar o parâmetro lista_colunas, deve conter o mesmo número de colunas como na petição de definição instruccion_selectda vista. Se omitir lista_colunas, as colunas da vista terão osmesmos nomes que os das colunas da instruccion_select da vista.As vistas e as tabelas devem ter nomes únicos.Se passar a opção OR REPLACE, a vista será recriada automaticamente caso já exista. Esta opção pode ser útil com opropósito de mudar a definição de uma vista existente sem ter que apagar/criar/afetar os privilégios dos objetos que já estãodefinidos para a vista atual.Se não passar a opção OR REPLACE, e se a vista já existe, se devolve um erro.nom_schema é também um nom_sql estandarte e pode ser utilizado para designar o nome do esquema que conterá a vista. Senão passar nom_schema ou se passar o nome de um esquema que não existe, a vista se atribui automaticamente ao esquemapor padrão, chamado "DEFAULT_SCHEMA".Instruccion_select designa a instrução SELECT que é a consulta de definição da vista. A Instruccion_select é a mesma que umSELECT estandarte de 4D, mas com as seguintes restrições:

Não pode utilizar as cláusulas INTO, LIMIT ou OFFSET pela limitação, a definição ou a atribuição das variáveis em 4D serálevada a cabo pela instrução MissingRef que chama a vista.Não pode utilizar a cláusula GROUP BY.As vistas são somente de leitura e não podem ser atualizadas.

Uma definição de vista é "estática" e não se atualiza se as tabelas fontes se modificam ou eliminam. Particularmente, as colunasadicionadas a uma tabela não aparecem na vista baseada nesta tabela. Do mesmo modo, se trata de acessar por meio de umavista as colunas eliminadas, se produz um erro.No entanto, uma vista que se refere a uma vista fonte eliminada seguirá funcionando. De fato, quando é criada uma vista, convertequalquer referência de vistas em referências as tabelas fonte. As vistas tem um alcance global. Uma vez que é criada uma vista com CREATE VIEW, é acessível para todas as partes daaplicação (4D remoto sob SQL, bases externas criadas com o comando CREATE DATABASE, outras bases utilizam ocomando SQL LOGIN, etc.) e em qualquer momento até que se apaga utilizando o comando DROP VIEW.

Exemplo

Aqui apresentamos alguns exemplos de definições de vista baseados na tabela PEOPLE que contém as seguintes colunas:ID INT64NOME VARCHAR(30)SOBRENOME VARCHAR(30)DEPARTAMENTO VARCHAR(30)SALÁRIO INT

Uma vista sem restrições:

CREATE VIEW FULLVIEW AS SELECT * FROM PERSONS;

Uma vista sem restrições: "horizontais". Por exemplo, você quer mostrar unicamente as pessoas que trabalham no departamentode Marketing:

CREATE VIEW HORIZONTALVIEW (ID, Nome, Sobrenome, Salário) AS

SELECT ID, FIRST_NAME, LAST_NAME, SALARY FROM PERSONS WHERE DEPARTMENT = 'Marketing';

Uma vista agregada:

CREATE VIEW AGGREGATEVIEW (Nombre, Apellido AnnualSalary) AS SELECT Nome, Sobrenome, SALARY*12 FROM PERSONS;

Uma vista com restrições "verticais". Por exemplo, você não quer mostrar a coluna SALARY:

CREATE VIEW VERTICALVIEW (ID, Nome, Sobrenome, Departamento) AS SELECT ID, FIRST_NAME, LAST_NAME, DEPARTEMENT FROM PERSONS;

Uma vez definidas as vistas, pode utilizar elas como tabelas estandarte. Por exemplo, se quer obter todas as pessoas cujo salárioé maior a 5,000 Euros:

SELECT * FROM FULLVIEW WHERE SALARY < 5000 INTO :aID, :aNome, :aSobrenome, :aDepartamento, :aSalário;

Outro exemplo: você quer obter todas as pessoas do departamento de Marketing cujo nome é "Miguel":

SELECT ID, Sobrenome, Salary FROM HORIZONTALVIEW WHERE Nome='Miguel' INTO :aID, :aSobrenome, :aSalary;

DROP VIEW

DROP VIEW [IF EXISTS] [schema_name.]view_name[;]

Descrição

O comando DROP VIEW apaga da base a vista chamada nom_vista.Quando passa a restrição IF EXISTS, o comando não faz nada e não é gerado nenhum erro se a vista nom_vista não existe nabase.nom_esquema é um nom_sql estandarte e pode ser utilizado para designar o nome do esquema que vai conter a vista. Se nãopassa nom_esquema ou se passa um nome de esquema que não existe, a vista se considera automáticamente como quepertence ao esquema por padrão, chamado "DEFAULT_SCHEMA".

GRANT

GRANT [READ | READ_WRITE | ALL] ON nom_sql TO nom_sql

Descrição

O comando GRANT permite definir os direitos de acesso associados ao esquema nom_sql. Estes direitos serão atribuídos aogrupo de usuários 4D designados pelo segundo parâmetro nom_sql.

As palavras chaves READ, READ_WRITE e ALL permitem definir os tipos de acesso autorizados para a tabela:

READ estabelece o modo de acesso somente de leitura (dados)READ_WRITE estabelece o modo de acesso leitura/escritura (dados)ALL estabelece o modo de acesso completo (dados e estrutura).

Note que cada tipo de acesso está definido independentemente dos outros. Em particular, se atribui só os direitos READ a umgrupo, isto não terá nenhum efeito já que o grupo como também os outros continuarão se beneficiando do acesso READ_WRITE(atribuído a todos os grupos por padrão). Para definir o acesso READ, deve chamar duas vezes o comando GRANT (ver exemplo2).

O controle de acesso só aplica as conexões externas. O código SQL executado ao interior de 4D via as etiquetas BeginSQL/End SQL ou os comandos tais como SQL EXECUTE tem acesso total.

Nota de compatibilidade: Durante a conversão de uma base anterior a versão 11.3 ou superior, os direitos de acesso globais(tais como os definidos na página SQL das Preferências da aplicação) se transferem ao esquema por padrão.

O primeiro parâmetro nom_sql deve conter o nome do grupo de usuários 4D ao que deseja atribuir direitos de acesso aoesquema. Este grupo deve existir na base 4D.

Nota: 4D permite definir os nomes de grupos incluindo espaços e/ou caracteres acentuados que não são aceitos por SQLpadrão. Neste caso, deve colocar o nome entre os caracteres [ e ]. Por exemplo: GRANT READ ON [meu esquema] TO [osadministradores]

Somente o Designer e o Administrador da base podem modificar os esquemas.

Nota sobre a integridade referencial

4D garante o princípio de integridade referencial independentemente dos direitos de acesso. Por exemplo, vamos supor quetenha duas tabelas, Tabela1 e Tabela2, conectadas por uma relação de tipo Muitos a Um (Tabela2 -> Tabela1). Tabela1 pertenceao esquema S1 e Tabela2 ao esquema S2. Um usuário que tenha direitos de acesso ao esquema S1 mas não ao S2 podeexcluir os registros na Tabela1. Neste caso, para respeitar os princípios de integridade referencial, todos os registros de Tabela2que estão relacionados com os registros excluídos da Tabela1 também serão removidos.

Exemplo 1

Você quer autorizar o acesso em leitura escritura de dados do esquema MeuEsquema1 ao grupo "Power_Users":

GRANT READ_WRITE ON MeuEsquema1 TO POWER_USERS

Exemplo 2

Você quer autorizar um acesso em leitura unicamente ao grupo "Readers". Este caso requer atribuir pelo menos um grupo comdireitos READ_WRITE (aquí "Admins") de forma que já não se atribui a todos os grupos por padrão:

GRANT READ ON MySchema2 TO Readers /*Atribuição do acesso em leitura unicamente */GRANT READ_WRITE ON MySchema2 TO Admins /*Deter o acesso a todos em leitura escritura*/

REVOKE

REVOKE [READ | READ_WRITE | ALL] ON nom_sql

Descrição

O comando REVOKE permite apagar os direitos de acesso específicos associados ao esquema definido pelo parâmetronom_sql.Quando executa este comando, atribui o pseudo-grupo de usuários <Pessoa> ao direito de acesso definido.

Exemplo

Você quer apagar todo direito leitura-escritura ao esquema MeuEsquema1:

REVOKE READ_WRITE ON MeuEsquema1

REPLICATE

REPLICATE lista_replicada FROM ref_tabela[WHERE critério_pesquisa][LIMIT {número_inteiro | ref_linguagem_4d}] [OFFSET {número_inteiro | ref_linguagem_4d}]FOR REMOTE [STAMP] {número_inteiro | ref_linguagem_4d} [, LOCAL [STAMP] {número_inteiro | ref_linguagem_4d}][{REMOTE OVER LOCAL | LOCAL OVER REMOTE}][LATEST REMOTE [STAMP] ref_linguagem_4d[, LATEST LOCAL [STAMP] ref_linguagem_4d]]INTO {lista_objetivo | ref_tabela(nom_sql_1;...;nom_sql_N)};

Descrição

O comando REPLICATE permite replicar os dados de uma tabela de uma base A na de uma tabela de uma base B. Porconvenção, a base onde é executado o comando se chama "base local" e a base da qual os dados se replicam se chama "baseremota".

Este comando só pode ser utilizado no marco de um sistema de replicação de base. Para que o sistema funcione, a replicaçãodeve ter sido ativada na base local e na base remota e cada tabela implicada deverá ter uma chave primaria. Para maiorinformação sobre este sistema, consulte a seção Replicação via SQL.

Nota: Se deseja implementar um sistema de sincronização completo, consulte a descrição do comando SYNCHRONIZE.

Passe uma lista de campos (virtuais ou padrão), separados por vírgulas em lista_replicada. Os campos devem pertencer a tabelaref_tabela da base remota.A cláusula FROM deve ir seguida de um argumento do tipo ref_tabela que permite designar a tabela da base remota desde aqual replicar os dados dos campos lista_replicada.

Nota: Os campos virtuais da tabela remota só podem ser armazenadas nos arrays da base local.

Lado base remota A cláusula opcional WHERE permite aplicar um filtro preliminar aos registros da tabela no banco de dados remoto; só aquelesregistros que cumpram com os critérios_de_pesquisa serão levados em consideração pelo comando.

4D recupera os valores dos campos lista_replicada para todos os registros designados pela cláusula FOR REMOTE STAMP. Ovalor passado nesta cláusula pode ser:

Um valor de tipo inteiro longo > 0: neste caso, são recuperados os registros onde o valor de __ROW_STAMP é maior ouigual a este valor.0: Neste caso, se recuperam todos os registros onde o valor de __ROW_STAMP é diferente de 0. Leve em conta que osregistros que existiam antes da ativação da replicação, não serão levados em consideração (o valor de __ROW_STAMP =0).-1: Neste caso, todos os registros da tabela remota se recuperam, ou seja, todos os registros onde o valor de__ROW_STAMP >= 0. A diferença do caso anterior, serão levados em consideração todos os registros da tabela, inclusiveos que existiam antes da ativação da replicação.-2: Neste caso, se recuperam todos os registros excluídos da tabela remota (depois da ativação da replicação), ou seja,todos os registros onde o valor de __ROW_ACTION = 2.

Por último, você pode aplicar a seleção obtida para as cláusulas opcionais OFFSET e/ou LIMIT:

Quando passada, a cláusula OFFSET permite ignorar os primeiros X registros da seleção (onde X é o valor passado acláusula).Quando passada, a cláusula LIMIT permite restringir a seleção aos Y primeiros registros da seleção (onde Y é o valorpassado a cláusula). Se a cláusula OFFSET também passa, a cláusula LIMIT se aplica a seleção obtida através daexecução de OFFSET.

Uma vez aplicadas ambas cláusulas, a seleção resultante se envia a base local.

Lado base local

Os valores recuperados se escrevem diretamente a lista_objetivo da base local ou nos campos padrão especificados pornom_sql da tabela ref_tabela da base local. O argumento lista_objetivo pode conter uma lista de campos padrão ou uma lista de arrays do mesmo tipo que os camposremotos (mas não uma combinação de ambos). Se o destino do comando é uma lista de campos, os registros objetivos serãocriados, modificados ou eliminados automaticamente em função da ação armazenada no campo virtual __ROW_ACTION.Os conflitos para os registros replicados que já existem na base objetivo (chaves primárias idênticas) se resolvem utilizando ascláusulas de prioridade (opção REMOTE OVER LOCAL e LOCAL OVER REMOTE):

Se passar a opção REMOTE OVER LOCAL omite a cláusula de prioridade, todos os registros fonte (base remota)designados pela cláusula FOR REMOTE STAMP substituem os registros objetivo (base local) se já existem, trocados ounão de um lado ou do outro. Neste caso, não tem sentido passar uma cláusula LOCAL STAMP porque será ignorada.Se passar a opção LOCAL OVER REMOTE, o comando leva em conta o marcador local LOCAL STAMP. Neste caso, osregistros objetivo (base local) cujo valor de marcador é inferior ou igual ao passado em LOCAL STAMP não sãosubstituídos pelos registros fonte (base remota). Por exemplo, se passar 100 em LOCAL STAMP, todos os registros dabase local cujo marcador seja menor ou igual a 100 serão substituídos pelos registros equivalentes da base remota. Esteprincípio permite preservar os dados modificados localmente e reduzir a seleção dos registros a replicar na tabela local.Se passar as cláusulas LATEST REMOTE STAMP e/ou LATEST LOCAL STAMP, 4D devolve nas variáveisref_linguagem_4D correspondentes os valores dos últimos marcadores das tabelas local e remota. Esta informação podeser útil se deseja personalizar a gestão do procedimento de sincronização. Estes valores correspondem ao valor dosmarcadores imediatamente depois de terminada a operação de replicação: se os utiliza em uma instrução REPLICATE ouSYNCHRONIZE, não é necessário executar porque são incrementados automaticamente antes de ser devolvidos pelocomando REPLICATE.

Se a operação de replicação é levada a cabo corretamente, a variável sistema OK toma o valor 1. Pode controlar este valordesde um método 4D.

Caso sejam produzidos erros durante a operação de replicação, a operação é detida quando ocorra o primeiro erro. A últimavariável fonte (caso especificado) toma o valor com o marcador do registro no qual foi produzido o erro. A variável sistema OKtoma o valor 0. O erro gerado pode ser interceptado por um método de gestão de erros instalado pelo comando ON ERR CALL.

Nota: As operações realizadas pelo comando REPLICATE não tem em conta as restrições de integridade de dados. Istosignifica, por exemplo, que as regras que regem as chaves externas, singularidade, etc. não são verificadas. Se os dadosrecebidos podem afetar a integridade dos dados, deve comprovar os dados depois da operação de replicação. A forma maissimples é bloquear, via a linguagem 4D ou SQL, os registros que devem ser modificados.

SYNCHRONIZE

SYNCHRONIZE [LOCAL] TABLE ref_tabela (ref_coluna_1,...,ref_coluna_N)WITH[REMOTE] TABLE ref_tabela (ref_coluna_1,...,ref_coluna_N)FOR REMOTE [STAMP] {número_inteiro | ref_linguagem_4d},LOCAL [STAMP] {número_inteiro | ref_linguagem_4d}{REMOTE OVER LOCAL | LOCAL OVER REMOTE}LATEST REMOTE [STAMP] ref_linguagem_4d,LATEST LOCAL [STAMP] ref_linguagem_4d;

Descrição

O comando SYNCHRONIZE permite sincronizar duas tabelas localizadas em dois servidores 4D SQL diferentes. Toda mudançarealizada em uma das tabelas também é realizada no outro. O servidor 4D SQL que executa o comando se chama servidor locale o outro servidor se chama servidor remoto.O comando SYNCHRONIZE é uma combinação de duas chamadas internas ao comando REPLICATE. A primeira chamadareplica os dados desde o servidor remoto ao servidor local e a segunda realiza a operação inversa: replicação dos dados doservidor local ao servidor remoto. As tabelas a sincronizar devem estar configuradas para a replicação

Devem ter uma chave primária,A opção "Ativar replicação" deve estar selecionada na janela Inspetor de cada tabela.

Para maior informação, consulte a descrição do comando REPLICATE.O comando SYNCHRONIZE aceita quatro marcadores (stamps) como "parâmetros": dois marcadores em entrada e doismarcadores em saída (última modificação). Os marcadores de entrada se utilizam para indicar o momento da últimasincronização em cada servidor. Os marcadores de saída devolvem o valor dos marcadores de modificação em cada servidorjusto depois da última modificação. Graças a este princípio, quando o comando SYNCHRONIZE se chama regularmente, épossível usar os marcadores de saída da última sincronização como marcadores de entrada para a seguinte. Nota: Os marcadores de entrada e de saída se expressam como valores numéricos (stamps) e não de marcadores de tempo(timestamps). Para obter mais informação sobre estes marcadores, consulte a descrição do comando REPLICATE. Em caso de erro, o marcador de saída do servidor em questão contém o marcador do registro a origem do erro. Se o erro deveser a uma causa diferente a sincronização (problemas de rede por exemplo), o marcador conterá 0.Há dois códigos de erro diferentes, um para indicar um erro de sincronização no site local e outro para um erro de sincronizaçãono site remoto.Quando ocorre um erro, o estado dos dados dependerá da transação no servidor local. No servidor remoto, a sincronização serealiza sempre dentro de uma transação, de forma que os dados não possam ser alterados pela operação. No entanto, noservidor local, o processo de sincronização fica sob o controle do desenvolvedor. É realizado fora de qualquer transação se apreferência Transações Auto-commit não está ativada, (caso contrário, um contexto de transação é criado automaticamente). Odesenvolvedor pode optar por iniciar uma transação e é responsabilidade do desenvolvedor validar ou cancelar esta transaçãodepois da sincronização dos dados. Pode "forçar" o endereço de sincronização utilizando as cláusulas REMOTE OVER LOCAL e LOCAL OVER REMOTE,dependendo das características de sua aplicação. Para maior informação sobre os mecanismos de implementação, consulte adescrição do comando REPLICATE. Nota: As operações realizadas pelo comando SYNCHRONIZE não levam em consideração restrições de integridade dos dados.Isto significa, por exemplo, que as regras que regem as chaves externas, singularidade, etc. não são verificadas. Se os dadosrecebidos podem afetar a integridade de dados, deve verificar os dados depois da operação de sincronização. A forma maissimples é bloquear, via a linguagem 4D ou SQL, os registros que devem ser modificados.Nas variáveis 4d_linguagem_ref das cláusulas LATEST REMOTE STAMP e LATEST LOCAL STAMP, 4D devolve os valoresdos últimos marcadores das tabelas remota e local. Esta informação lhe permite automatizar a gestão do procedimento desincronização. Estes valores correspondem ao valor dos marcadores até o final da operação de replicação: se os utiliza em umainstrução REPLICATE ou SYNCHRONIZE posterior, não os necessita incrementar; se incrementam automaticamente antes deser devolvidos pelo comando REPLICATE.

Exemplo

Para entender os mecanismos envolvidos na operação de sincronização, vamos a examinar as diferentes possibilidades relativasa atualização de um registro existente nas duas bases sincronizadas.

O método de sincronização é da seguinte forma:

C_LONGINT(vRemoteStamp) C_LONGINT(vLocalStamp) C_LONGINT(vLatestRemoteStamp) C_LONGINT(vLatestLocalStamp) vRemoteStamp:=X... // ver valores no array a continuação vLocalStamp:=X... // ver valores no array a continuação vLatestRemoteStamp:=X... // valor devolvido em um anterior LATEST REMOTE STAMP vLatestLocalStamp:=X... // valor devolvido em um anterior LATEST LOCAL STAMP Begin SQL SYNCHRONIZE LOCAL MYTABLE (MyField) WITH REMOTE MYTABLE (MyField) FOR REMOTE STAMP :vRemoteStamp, LOCAL STAMP :vLocalStamp LOCAL OVER REMOTE // or REMOTE OVER LOCAL, ver no array a continuação LATEST REMOTE STAMP :vLatestRemoteStamp, LATEST LOCAL STAMP :vLatestLocalStamp; End SQL

Os dados iniciais são:

O marcador do registro na base LOCAL tem um valor de 30 e o da base REMOTA tem um valor de 4000Os valores do campo MeuCampo são os seguintes:

LOCAL REMOTEAntigo valor Novo valor Antigo valor Novo valorAAA BBB AAA CCC

Utilizamos os valores devolvidos pelas cláusulas anteriores LATEST LOCAL STAMP e LATEST REMOTE STAMP parasincronizar unicamente os valores que foram modificados desde a última sincronização.

Estas são as sincronizações realizadas pelo comando SYNCHRONIZE em função dos valores passados nos parâmetrosLOCAL STAMP e REMOTE STAMP como também a opção de prioridade utilizada: ROL (para REMOTE OVER LOCAL) ouLOR (para LOCAL OVER REMOTE):

LOCALSTAMP

REMOTESTAMP Prioridade LOCAL depois de

sincREMOTA depois desinc

Sincronização LOCAL -REMOTA

20 3000 ROL CCC CCC <---->20 3000 LOR BBB BBB <---->31 3000 ROL CCC CCC <--31 3000 LOR CCC CCC <--20 4001 ROL BBB BBB -->20 4001 LOR BBB BBB -->31 4001 ROL BBB CCC Sem sincronização31 4001 LOR BBB CCC Sem sincronização40 3000 ROL CCC CCC <--40 3000 LOR CCC CCC <--20 5000 ROL BBB BBB -->20 5000 LOR BBB BBB -->40 5000 ROL BBB CCC Sem sincronização40 5000 LOR BBB CCC Sem sincronização

Regras de sintaxe

Regras de sintaxe chamada_função_4d ref_linguagem_4d predicado_all_or_any expressão_aritmética predicado_between expressão_condicional definição_coluna ref_coluna parâmetro_comando predicado_comparaison predicado_exists definição_chave_externa function_call predicado_in predicado_is_null predicado_like literal predicado definição_chave_primária criterio_pesquisa select_item lista_ordem tipo_datos_sql nom_sql cadeia_sql sub_consulta restrição_tabela ref_tabela

Regras de sintaxe

Esta seção descreve o conteúdo e o uso de diferentes elementos dos predicados utilizados nas instruções SQL. Agrupamos deforma que possamos descrever de maneira simples e dar indicações generais sobre seu modo de uso dentro de 4D. As palavraschaves (em itálico) sempre são passadas "tal qual" quando se utilizam.

chamada_função_4d

{FN nom_sql ([expressão_aritmética, ..., expressão_aritmética]) AS tipo_dados_sql}

Descrição

chamada_função_4d permite executar uma função 4D que devolve um valor.O argumento nom_sql da função está precedido pela palavra chave FN e seguido por um ou vários argumentos de tipoexpressão_aritmética. O valor devolvido pela função será do tipo definido por tipo_dados_sql.

Exemplo

Este exemplo utiliza funções para extrair da tabela MOVIES o número de atores para cada filme que tenha ao menos 7 atores:

C_LONGINT($NrOfActors) ARRAY TEXT(aMovieTitles;0) ARRAY LONGINT(aNrActors;0) $NrOfActors:=7 Begin SQL SELECT Movie_Title, {FN Find_Nr_Of_Actors(ID) AS NUMERIC} FROM MOVIES WHERE {FN Find_Nr_Of_Actors(ID) AS NUMERIC} >= :$NrOfActors ORDER BY 1 INTO :aMovieTitles; :aNrActors End SQL

ref_linguagem_4d

<<sql_name>> |<<$sql_name>> | <<[sql_name]sql_name>> | :sql_name|:$sql_name|:sql_name.sql_name

Descrição

Um argumento ref_linguagem_4d especifica um nome de variável ou de campo 4D (nom_sql) destinado a receber dados. Estenome pode ser passado em uma destas formas:<<nom_sql>><<$nom_sql>> (*)<<[nom_sql]nom_sql>> (corresponde a sintaxe 4D padrão: [NomeTabela]NomeCampo):nom_sql:$nom_sql (*):nom_sql.nom_sql (corresponde a sintaxe SQL padrão: NomeTabela.NomeCampo)(*) Em modo compilado, não pode utilizar referencias a variáveis locais (que começam pelo símbolo $).

predicado_all_or_any

expressão_aritmética {< | <= | = | >= | > | <>} {ANY | ALL | SOME} (sub_pesquisa)

Descrição

Um predicado_all_or_any se utiliza para comparar uma expressão_aritmética com uma sub_pesquisa. Pode passar operadoresde comparação tais como <, <=, =, >=, > ou <> como também as palavras chaves ANY, ALL e SOME para realizar a comparaçãocom a sub_pesquisa.

Exemplo

O exemplo realiza uma subconsulta que seleciona as melhores vendas de software. A pesquisa principal seleciona os registrosdas tabelas VENDAS e CLIENTES onde Valor_Total é superior aos registros selecionados pela subconsulta:

SELECT Valor_Total, CLIENTES.ClienteFROM VENDAS, CLIENTESWHERE VENDAS.Cliente_ID = CLIENTES.Cliente_IDAND Valor_Total > ALL (SELECT MAX (Valor_Total)FROM VENDASWHERE Tipo_produto = 'Software');

expressão_aritmética

val_literal |

ref_coluna |

chamada_função |

parâmetro_comando |

expressão_condicional |

(expressão_aritmética) |

+ expressão_aritmética |

- expressão_aritmética |

expressão_aritmética + expressão_aritmética |

expressão_aritmética - expressão_aritmética |

expressão_aritmética * expressão_aritmética |

expressão_aritmética / expressão_aritmética |

Descrição

Uma expressão_aritmética pode conter um valor literal (val_literal), uma referencia de coluna (ref_coluna), uma chamada defunção (chamada_função), um parâmetro de comando (parâmetro_comando) ou uma expressão de tipo expressão_condicional.Também pode passar combinações de expressões aritméticas utilizando os operadores +, -, * e /.

predicado_between

expressão_aritmética [NOT] BETWEEN expressão_aritmética AND expressão_aritmética

Descrição

O predicado_between permite buscar os dados cujos valores estão entre dois valores de tipo expressão_aritmética (passadosem ordem ascendente). Também pode passar a palavra chave opcional NOT com o propósito de excluir os valores que não estãodentro destes limites.

Exemplo

Este exemplo seleciona todos os clientes cujos nomes começam por uma letra entre a A e a E:

SELECT CLIENT_NOM, CLIENT_SOBRENOMEFROM T_CLIENTWHERE CLIENT_NOME BETWEEN 'A' AND 'E'

expressão_condicional

expressão_condicional

Descrição

Uma expressão_condicional permite aplicar uma ou várias condições ao selecionar uma expressão.Pode ser utilizada por exemplo da seguinte forma:

CASEWHEN critério_pesquisa THEN expressão_aritmética...WHEN critério_pesquisa THEN expressão_aritmética[ELSE expressão_aritmética]END

Ou:

CASE expressão_aritméticaWHEN expressão_aritmética THEN expressão_aritmética...WHEN expressão_aritmética THEN expressão_aritmética[ELSE expressão_aritmética]END

Exemplo

Este exemplo seleciona registros da coluna de números de quartos em função do valor da coluna PISO_QUA:

SELECT NUM_HABCASE PISO_QUAWHEN 'Piso térreo' THEN 0WHEN 'Primeiro piso' THEN 1WHEN 'Segundo piso' THEN 2END AS PISOS, QUARTOFROM T_HABSORDER BY PISOS, QUARTO

definição_coluna

nom_sql tipo_dados_sql [(número_inteiro)][NOT NULL] [UNIQUE] [AUTO_INCREMENT]

Description

Uma definição de coluna (definição_coluna) contém o nome (nom_sql) e o tipo de dados (tipo_dados_sql) de uma coluna.Opcionalmente, também pode passar um numero_inteiro como as palavras chaves NOT NULL, UNIQUE, AUTO_INCREMENTe/ou AUTO_GENERATE.

Passar NOT NULL na definição_coluna significa que a coluna não aceita valores nulos.Passar UNIQUE significa que o mesmo valor não poderá ser inserido nesta coluna duas vezes. Leve em consideração quesó as colunas NOT NULL podem ter o atributo UNIQUE. A palavra chave UNIQUE deverá sempre ir precedida por NOTNULL.Passar AUTO_INCREMENT significa que a coluna vai gerar um número único para cada nova linha. Este atributo só podeser usado com as colunas de números.Passar AUTO_GENERATE significa que um UUID será gerado automaticamente na coluna para cada nova linha. Esteatributo só pode ser utilizado com as colunas UUID.

Cada coluna deve ter um tipo de dados. A coluna deve ser definida como "nula" ou não "nula" e se este valor é deixado embranco, o banco de dados assume "nula" como valor predeterminado. O tipo de dados para a coluna não restringe os dados quepodem ser colocados nesta coluna.

Example

Este exemplo cria uma tabela com duas colunas, ID e Nome):

CREATE TABLE ACTOR_FANS(ID INT32, Nom VARCHAR NOT NULL UNIQUE);

ref_coluna

nom_sql | nom_sql.nom_sql | cadeia_sql.cadeia_sql

Descrição

Uma referencia de coluna (ref_coluna) consiste de um nom_sql ou de uma cadeia_sql passada de uma das seguintes formas:nom_sqlnom_sql.nom_sqlcadeia_sql.cadeia_sql

parâmetro_comando

? | <<nom_sql>> | <<$nom_sql>> | <<[nom_sql]nom_sql>> | :nom_sql | :$nom_sql | :nom_sql.nom_sql

Descrição

Um argumento parâmetro_comando pode ser um signo de interrogação (?) ou um nom_sql passado em uma das seguintesformas:?<<nom_sql>><<$nom_sql>><<[nom_sql]nom_sql>>:nom_sql:$nom_sql:nom_sql.nom_sql

predicado_comparaison

expressão_aritmética {< |<= |= | >= | > | <> }expressão_aritmética |

expressão_aritmética {< |<= |= | >= | > | <> } (sub_consulta) |

(sub_consulta) {< |<= |= | >= | > | <> } expressão_aritmética

Descrição

Um argumento predicado_comparação utiliza os operadores <, <=, =, >=, > ou <> para comparar dois argumentos de tipoexpressão_aritmética ou para comparar uma expressão_aritmética com uma sub_consulta como parte de um critério_pesquisaaplicado aos dados.

predicado_exists

EXISTS (sub_consulta)

Descrição

O predicado EXISTS permite executar uma sub_consulta e depois verificar se devolve um valor. Este resultado se obtémpassando a palavra chave EXISTS seguida da sub_consulta.

Exemplo

Este exemplo devolve o total das vendas quando tem uma loja na região especificada:

SELECT SUM (Vendas)FROM Informação_LojaWHERE EXISTS(SELECT * FROM GeografiaWHERE nome_região = 'Ocidente')

definição_chave_externa

CONSTRAINT nom_sql

FOREIGN KEY (ref_coluna, ... , ref_coluna)

REFERENCES nom_sql [(ref_coluna, ... , ref_coluna)]

[ON DELETE {RESTRICT |CASCADE}]

[ON UPDATE {RESTRICT |CASCADE}]

Descrição

Uma definição de chave externa (definição_chave_externa) se usa para fazer corresponder os campos chaves primárias(ref_coluna) definidos em outra tabela com a função de preservar a integridade dos dados. A restrição FOREIGN KEY permitepassar as referencias de uma ou mais colunas (ref_coluna) a definir como chaves externas (correspondentes as chaves primáriasde outra tabela).

A cláusula CONSTRAINT nom_sql se utiliza para nomear a restrição FOREIGN KEY.

A cláusula REFERENCES permite especificar os campos chaves primárias fonte correspondentes na outra tabela (designadapor nom_sql). Pode omitir a lista de campos (argumentos ref_coluna) se a tabela (nom_sql) definida na cláusula REFERENCEStem uma chave primária que será utilizada como a chave correspondente para a restrição chave externa.

A cláusula opcional ON DELETE CASCADE especifica que quando se elimina uma linha da tabela pai (que contém os camposchaves primárias), também é excluída das linhas associadas com a linha da tabela filho (que contém os campos chaves externas).Passar a cláusula opcional ON DELETE RESTRICT evita a eliminação de dados de uma tabela se outras tabelas asreferenciam.

A cláusula opcional ON UPDATE CASCADE especifica que sempre que se atualiza uma linha na tabela pai (que contém oscampos de chaves primárias), também se atualiza nas linhas associadas a essa linha da tabela filho (que contém os camposchaves externas). Passar a cláusula opcional ON UPDATE RESTRICT evita a atualização dos dados de uma tabela se outrastabelas as referenciam.Tenha em conta que se passadas as duas cláusulas ON DELETE e ON UPDATE, ambas devem ser do mesmo tipo (porexemplo, ON DELETE CASCADE e ON UPDATE CASCADE ou ON DELETE RESTRICT e ON UPDATE RESTRICT).Se não passam nem a cláusula ON DELETE nem a ON UPDATE, então CASCADE se utiliza como a regra por padrão.

Exemplo

Este exemplo cria a tabela ORDENES depois define a coluna SID_Clientes como chave externa, associada a coluna SID databela CLIENTES:

CREATE TABLE ORDENES(ID_Ordem INT32,SID_Clientes INT32,Quantidade NUMERIC,PRIMARY KEY (ID_Comando),CONSTRAINT fk_1 FOREIGN KEY (SID_Clientes) REFERENCES CLIENTES(SID));

function_call

chamada_função_sql |chamada_função_4d

Descrição

Uma chamada_função pode ser uma chamada as ou a uma função 4D (chamada_função_4d). Os dois tipos de funções podemmanipular os dados, devolver os resultados e operar em um ou mais argumentos.

Exemplo

Este exemplo utiliza a função SQL COUNT:

C_LONGINT(vNumPessoa) Begin SQL SELECT COUNT (*) FROM VENDEDORES INTO :vNumPessoa; End SQL

predicado_in

expressão_aritmética [NOT] IN (sub_consulta) |expressão_aritmética [NOT] IN (expressão_aritmética, ..., expressão_aritmética)

Descrição

O predicado predicado_in permite comparar sem uma expressão_aritmética for incluída (ou não é incluída se a palavra chavetambém NÃO passa) em uma lista de valores. O conjunto de valores utilizados pela comparação pode ser uma sequência deexpressões aritméticas, que são passada ou o resultado de uma sub_consulta.

Exemplo

Este exemplo seleciona os registros da tabela ORDENS cujo valor da coluna id_ordem é igual a 10000, 10001, 10003 ou 10005:

SELECT *FROM ORDERSWHERE id_order IN (10000, 10001, 10003, 10005);

predicado_is_null

expressão_aritmética IS [NOT] NUL

Descrição

O predicado IS NULL permite encontrar uma expressão_aritmética com um valor NULL. Também pode passar a palavra chaveNOT para buscar as expressões sem valores NULL.

Exemplo

Este exemplo seleciona os produtos cujo peso é menor a 15 ou cuja coluna Color contenha o valor NULL:

SELECT Nome, Peso, CorFROM PRODUCTSWHERE Peso < 15.00 OR Color IS NULL

predicado_like

expressão_aritmética [NOT] LIKE expressão_aritmética [ESCAPE cadeia_sql]

Descrição

O predicado LIKE permite selecionar os dados correspondentes a expressão_aritmética passada depois da palavra chaveLIKE. Também pode passar a palavra chave NOT para selecionar os dados que não correspondam a esta expressão. Podeutilizar a palavra chave ESCAPE para evitar que o caráter passado em cadeia_sql se interprete como um curinga. Geralmente seutiliza quando quer procurar os caracteres '%' o '_'.

Exemplo 1

Este exemplo seleciona os provedores cujo nome contenha "bob":

SELECT * FROM provedoresWHERE nome LIKE '%bob%';

Exemplo 2

Este exemplo seleciona os provedores cujo nome não começa pela letra T:

SELECT * FROM provedoresWHERE nome NOT LIKE 'T%';

Exemplo 3

Este exemplo seleciona os provedores cujo nome comece por "Sm" e termine em "th":

SELECT * FROM provedoresWHERE nome LIKE 'Sm_th'

literal

número_inteiro | número_fracionário | cadeia_sql |número_hexadecimal

Descrição

Um valor literal é um dado de tipo número_inteiro (inteiro), um número_fracionário (fração), uma cadeia_sql ou umnúmero_hexadecimal.A notação hexadecimal (introduzida em 4D 12.1) permite expressar todo tipo de dados representados como bytes. Um bytesempre está definido por dois valores hexadecimais. Para indicar o uso desta notação em um comando SQL, simplesmente deveutilizar a sintaxe hexadecimal SQL padrão:

X'<valor hexadecimal>'

Por exemplo, para o valor decimal 15, pode escrever X'0f'. Pode definir um valor vazio (zero byte) escrevendo X''.Nota: Os comandos SQL EXPORT DATABASE e SQL EXPORT SELECTION exportam dados binários ao formatohexadecimal quando estes dados estão incluídos no arquivo principal.

predicado

predicado

Descrição

Um predicado segue a cláusula WHERE e permite agregar as condições de pesquisa para a seleção dos dados. Pode ser deum dos seguintes tipos:predicado_comparaisonpredicado_betweenpredicado_likepredicado_is_nullpredicado_inpredicado_all_or_anypredicado_exists

definição_chave_primária

[CONSTRAINT nom_sql] PRIMARY KEY (nom_sql, ... , nom_sql)

Descrição

Um argumento de tipo definição_chave_primária permite passar a coluna ou a combinação de colunas (nom_sql) que seráutilizada como chave primária (PRIMARY KEY, número único) da tabela. A ou as coluna(s) passadas não devem conterduplicados nem valores NULL.Uma restrição opcional CONSTRAINT também pode preceder a chave PRIMARY KEY passada com o propósito de limitar osvalores que possam ser inseridos na coluna.

Exemplo

Este exemplo cria uma tabela e define a coluna SID como chave primária:

CREATE TABLE Clientes(SID int32,Nome varchar(30),Sobrenome varchar(30),PRIMARY KEY (SID));

criterio_pesquisa

predicado |NOT critério_pesquisa |(critério_pesquisa) |critério_pesquisa OR critério_pesquisa |critério_pesquisa AND critério_pesquisa

Descrição

Um critério_pesquisa especifica uma condição a aplicar aos dados selecionados. Também é possível passar uma combinaçãode condições de pesquisa utilizando as palavras chaves AND e OR. Também pode preceder um critério_pesquisa com a palavrachave NOT para recuperar os dados que não cumprem com a condição definida.Também é possível passar um predicado como critério_pesquisa.

Exemplo

Este exemplo utiliza uma combinação de critérios de pesquisa na cláusula WHERE:

SELECT provedor_idFROM provedorWHERE (nome = 'CANON')OR (nome = 'Hewlett Packard' AND city = 'New York')OR (nome = 'Firewall' AND status = 'Fechado' AND city = 'Chicago');

select_item

expressão_aritmética [[AS] {cadeia_sql |nom_sql}]

Descrição

Um select_item especifica um ou vários elementos a incluir nos resultados. Uma coluna é gerada para cada select_itempassado. Cada select_item consiste de uma expressão_aritmética. Também pode passar a palavra chave opcional AS com opropósito de especificar uma cadeia_sql ou um nom_sql a passar a coluna. (Passar uma cadeia_sql ou nom_sql sem a palavrachave AS tem o mesmo efeito).

Exemplo

Este exemplo cria uma coluna chamada Ano_Filme que contém os filmes realizados a partir do ano 2000:

ARRAY INTEGER(AnoFilme;0) Begin SQL SELECT Ano_de_estréia AS Ano_Filme FROM MOVIES WHERE Ano_Filme >= 2000 ORDER BY 1 INTO :AnoFilme; End SQL

lista_ordem

{ref_coluna | número_inteiro} [ASC | DESC], ... , {ref_coluna | número_inteiro} [ASC |DESC]

Descrição

Um argumento de tipo lista_ordem contém uma referencia de coluna ref_coluna ou um número número_inteiro que define acoluna cujos valores devem ser ordenados. Também pode passar as palavras chaves ASC ou DESC com a função deespecificar se a ordem deve ser ascendente ou descendente. Por padrão, a ordem é ascendente.

nom_sql

nom_sql

Descrição

Um nom_sql é um nome SQL padrão que começa por um caracter do alfabeto Latino e contém unicamente os caracteres latinos,os números e/ou sublinhados, ou uma cadeia entre colchetes. Passe dois colchetes diretos como caracteres de escape para ocolchete direito.Exemplos:

Cadeia a passar nom_sqlMeuNomeSQL_2 MeuNomeSQL_2Meu nome !&^#%!&#% não padrão [Meu nom !&^#%!&#% não padrão][nome entre colchetes] [[nome entre colchetes]]]nome com [] colchetes [nome com []] colchetes]

cadeia_sql

cadeia_sql

Descrição

Uma cadeia_sql contém uma cadeia de caracteres entre apóstrofes. Os apóstrofes na cadeia devem ser duplos e as cadeiasque já estão entre apóstrofes devem ser triplicados.Exemplos:

Cadeia a passar cadeia_sqlminha cadeia 'minha cadeia'cadeia com ' dentro 'cadeia com ' ' dentro''cadeia entre apóstrofes' ' ' 'cadeia entre apóstrofes' ' '

sub_consulta

SELECT [ALL | DISTINCT]{* | select_item, ..., select_item}FROM ref_tabela, ..., ref_tabela[WHERE critério_pesquisa][GROUP BY lista_ordem][HAVING critério_pesquisa][LIMIT {número_inteiro | ALL}][OFFSET número_inteiro]

Descrição

Uma sub_consulta É como uma instrução SELECT independente entre parênteses e passada no predicado de outra instruçãoSQL (SELECT, INSERT, UPDATE ou DELETE). Atua como um pedido em uma pesquisa e com frequência é passada comoparte de uma cláusula WHERE ou HAVING.

restrição_tabela

{definição_chave_primária | definição_chave_externa}

Descrição

Uma restrição_tabela restringe os valores que uma tabela pode armazenar. Pode passar uma definição_chave_primária ou umadefinição_chave_externa. A definição_chave_primária define a chave primária para a tabela e a definição_chave_externa seutiliza para definir a chave externa (que corresponde a chave primária de outra tabela).

ref_tabela

{nom_sql | cadeia_sql} [[AS] {nom_sql|cadeia_sql}]

Descrição

Uma referencia de tabela pode ser um nome SQL padrão ou uma cadeia. Também pode passar a palavra chave opcional ASpara atribuir um alias (na forma de um nom_sql ou cadeia_sql) a coluna. (Passar uma cadeia_sql ou um nom_sql sem a palavrachave AS tem o mesmo efeito).

Transações

Transações START COMMIT ROLLBACK

Transações

Descrição

As transações são um conjunto de instruções SQL executadas em bloco. Ou todas as instruções têm êxito ou nenhuma delas. Astransações utilizam blocos para preservar a integridade dos dados durante sua execução. Se a transação termina corretamente,pode utilizar o comando COMMIT para armazenar permanentemente suas modificações. Caso contrário, chame o comandoROLLBACK para cancelar todas as modificações e restaurar o banco de dados a seu estado anterior.

Não há diferença entre uma transação 4D e uma transação SQL. Os dois tipos compartilham os mesmos dados e processos. Asinstruções SQL incluídas em uma estrutura Begin SQL/End SQL, o comando QUERY BY SQL e os comandos SQL genéricosintegrados aplicados a base local sempre se executam no mesmo contexto que os comandos 4D padrão.Nota: 4D oferece a opção "Auto-commit" que pode ser utilizada para iniciar e validar as transações de forma automática ao usaros comandos SIUD (SELECT, INSERT, UPDATE e DELETE) com o propósito de preservar a integridade dos dados. Paramaior informação, consulte a seção .Os seguintes exemplos ilustram as diferentes combinações de transações.

Nem "John", nem "Smith" serão adicionados a tabela emp:

SQL LOGIN(SQL_INTERNAL;"";"") Ìnicializar o motor SQL de 4D START TRANSACTION Ìniciar uma transação no processo atual Begin SQL INSERT INTO emp (NAME) VALUES ('John'); End SQL SQL EXECUTE("START") Òutra transação no processo atual SQL CANCEL LOAD SQL EXECUTE("INSERT INTO emp (NAME) VALUES ('Smith')") Èsta instrução éexecutada no mesmo processo SQL CANCEL LOAD SQL EXECUTE("ROLLBACK") `Cancelar a transação interna do processo CANCEL TRANSACTION `Cancelar a transação externa do processo SQL LOGOUT

Somente “John” será adicionado a tabela emp:

SQL LOGIN(SQL_INTERNAL;"";"") START TRANSACTION Begin SQL INSERT INTO emp(NAME) VALUES ('John'); End SQL SQL EXECUTE("START") SQL CANCEL LOAD SQL EXECUTE("INSERT INTO emp (NAME) VALUES ('Smith')") SQL CANCEL LOAD SQL EXECUTE("ROLLBACK") `Cancelar a transação interna do processo VALIDATE TRANSACTION `Validar a transação externa do processo SQL LOGOUT

Nem “John” nem “Smith” serão adicionados a tabela emp. A transação externa anula a transação interna:

SQL LOGIN(SQL_INTERNAL;"";"") START TRANSACTION Begin SQL INSERT INTO emp (NAME) VALUES ('John'); End SQL SQL EXECUTE("START") SQL CANCEL LOAD SQL EXECUTE("INSERT INTO emp (NAME) VALUES ('Smith')") SQL CANCEL LOAD SQL EXECUTE("COMMIT") `Validar a transação interna do processo CANCEL TRANSACTION `Cancelar a transação externa do processo SQL LOGOUT

“John” e “Smith” serão adicionados a tabela emp:

SQL LOGIN(SQL_INTERNAL;"";"") START TRANSACTION Begin SQL INSERT INTO emp (NAME) VALUES ('John'); End SQL SQL EXECUTE("START") SQL CANCEL LOAD SQL EXECUTE("INSERT INTO emp (NAME) VALUES ('Smith')") SQL CANCEL LOAD SQL EXECUTE("COMMIT") `Validar a transação interna do processo VALIDATE TRANSACTION `Validar a transação externa do processo SQL LOGOUT

START

START [TRANSACTION]

Descrição

O comando START se utiliza para definir o inicio de uma transação. Se este comando se executa quando uma transação está emcurso, se inicia uma sub transação. A palavra chave TRANSACTION é opcional.

Exemplo

Este exemplo realiza uma seleção ao interior de uma transação:

START TRANSACTION;SELECT * FROM suppliersWHERE supplier_name LIKE '%bob%';COMMIT TRANSACTION;

COMMIT

COMMIT [TRANSACTION]

Descrição

O comando COMMIT define o final de uma transação executada com sucesso. Este comando garante que todas as modificaçõesrealizadas durante a transação se tornam parte permanente da base. Também libera os recursos utilizados pela transação.Lembre que não pode utilizar o comando ROLLBACK depois de um COMMIT já que as mudanças são permanentes. A palavrachave TRANSACTION é opcional.

Exemplo

Ver o exemplo do comando START.

ROLLBACK

ROLLBACK [TRANSACTION]

Descrição

O comando ROLLBACK cancela a transação em curso e restaura os dados a seu estado anterior ao começo da transação.Também libera todos os recursos utilizados pela transação. A palavra chave TRANSACTION é opcional.

Exemplo

Este exemplo ilustra o uso do comando ROLLBACK:

START TRANSACTIONSELECT * FROM suppliersWHERE supplier_name like '%bob%';ROLLBACK TRANSACTION;

Funções

Funções SQL ABS ACOS ASCII ASIN ATAN ATAN2 AVG BIT_LENGTH CAST CEILING CHAR CHAR_LENGTH COALESCE CONCAT CONCATENATE COS COT COUNT CURDATE CURRENT_DATE CURRENT_TIME CURRENT_TIMESTAMP CURTIME DATABASE_PATH DATE_TO_CHAR DAY DAYNAME DAYOFMONTH DAYOFWEEK DAYOFYEAR DEGREES EXP EXTRACT FLOOR HOUR INSERT LEFT LENGTH LOCATE LOG LOG10 LOWER LTRIM MAX MILLISECOND MIN MINUTE MOD MONTH MONTHNAME NULLIF OCTET_LENGTH PI

POSITION POWER QUARTER RADIANS RAND REPEAT REPLACE RIGHT ROUND RTRIM SECOND SIGN SIN SPACE SQRT SUBSTRING SUM TAN TRANSLATE TRIM TRUNC TRUNCATE UPPER WEEK YEAR

Funções SQL

As funções SQL são aplicadas as colunas de dados com o propósito de devolver um resultado específico em 4D. Os nomes dasfunções aparecem em itálico e são passadas como estão, geralmente seguidos de um ou vários argumentos de tipoexpressão_aritmética.

ABS

ABS (expressão_aritmética)

Descrição

A função ABS devolve o valor absoluto da expressão_aritmética.

Exemplo

Este exemplo devolve o valor absoluto dos preços e os multiplica por uma certa quantidade:

ABS(Price) * quantity

ACOS

ACOS (expressão_aritmética)

Descrição

A função ACOS devolve o arco cosseno da expressão_aritmética. É o inverso da função COS. A expressão_aritméticarepresenta o ângulo expressado em radianos.

Exemplo

Este exemplo devolve o arco-cosseno do ângulo de -0.73 radianos:

SELECT ACOS(-0.73)FROM TABLES_OF_ANGLES;

ASCII

ASCII (expressão_aritmética)

Descrição

A função ASCII devolve o caracter mais a esquerda da expressão_aritmética como um inteiro. Se a expressão_aritmética estávazia, a função devolve o valor NULL.

Exemplo

Este exemplo devolve a primeira letra de cada sobrenome como um inteiro:

SELECT ASCII(SUBSTRING(Sobrenome,1,1))FROM PEOPLE;

ASIN

ASIN (expressão_aritmética)

Descrição

A função ASIN devolve o arco cosseno da expressão_aritmética. É o inverso da função (SIN). A expressão_aritméticarepresenta o ângulo expressado em radianos.

Exemplo

Este exemplo devolve o arco cosseno do ângulo de -0.73 radianos:

SELECT ASIN(-0.73)FROM TABLES_OF_ANGLES;

ATAN

ATAN (expressão_aritmética)

Descrição

A função ATAN devolve o arco tangente da expressão_aritmética. É o inverso da função tangente (TAN). A expressão_aritméticarepresenta o ângulo expressado em radianos.

Exemplo

Este exemplo devolve o arco tangente do ângulo de -0.73 em radianos:

SELECT ATAN(-0.73)FROM TABLES_OF_ANGLES;

ATAN2

ATAN2 (expressão_aritmética, expressão_aritmética)

Descrição

A função ATAN2 devolve o arco tangente das coordenadas "x" e "y", onde "x" é a primeira expressão_aritmética passada e "y" asegunda.

Exemplo

Este exemplo devolve o arco tangente das coordenadas 0.52 e 0.60:

SELECT ATAN2( 0.52, 0.60 );

AVG

AVG ([ALL | DISTINCT] expressão_aritmética)

Descrição

A função AVG devolve a média da expressão_aritmética. As palavras chaves opcionais ALL e DISTINCT permitemrespectivamente incluir ou excluir os valores duplicados.

Exemplo

Este exemplo devolve o valor mínimo, máximo, média e total dos ingressos vendidos para a tabela MOVIES:

SELECT MIN(Tickets_Vendidos),MAX(Tickets_Vendidos),AVG(Tickets_Vendidos),SUM(Tickets_Vendidos)FROM MOVIES

BIT_LENGTH

BIT_LENGTH (expressão_aritmética)

Descrição

A função BIT_LENGTH devolve a longitude em bits da expressão_aritmética.

Exemplo

Este exemplo devolve 8:

SELECT BIT_LENGTH( '01101011' );

CAST

CAST (expressão_aritmética AS tipo_dados_sql)

Descrição

A função CAST converte a expressão_aritmética no tipo_dados_sql passado depois da palavra chave AS.

Exemplo

Este exemplo converte o ano do filme em Inteiro:

SELECT Ano_Realização, Título, Diretor, Média, Tickets_vendidosFROM MOVIESWHERE Ano_Realização >= CAST('1960' AS INT)

CEILING

CEILING (expressão_aritmética)

Descrição

A função CEILING devolve o inteiro mais pequeno que seja maior ou igual a expressão_aritmética.

Exemplo

Este exemplo devolve o inteiro mais pequeno que seja maior ou igual a -20.9:

CEILING (-20.9)`devolve -20

CHAR

CHAR (expressão_aritmética)

Descrição

A função CHAR devolve uma cadeia de caracteres de longitude fixa baseada no tipo da expressão_aritmética passada.

Exemplo

Este exemplo devolve uma cadeia de caracteres baseada no código da primeira letra de cada sobrenome:

SELECT CHAR(ASCII(SUBSTRING(Sobrenome,1,1)))FROM PEOPLE;

CHAR_LENGTH

CHAR_LENGTH (expressão_aritmética)

Descrição

A função CHAR_LENGTH devolve o número de caracteres presentes na expressão_aritmética.

Exemplo

Este exemplo devolve o número de caracteres no nome dos produtos com peso menor a 15 lbs.

SELECT CHAR_LENGTH (Nome)FROM PRODUCTSWHERE Weight < 15.00

COALESCE

COALESCE (expressão_aritmética, ..., expressão_aritmética)

Descrição

A função COALESCE devolve o valor da primeira expressão no null da lista de argumentos de tipo expressão_aritméticapassado. A função devolve NULL se todas as expressões passadas são NULL.

Exemplo

Este exemplo devolve todos os números de faturas desde o ano 2007 onde o IVA é superior a 0:

SELECT NO_FATURASFROM FATURASWHERE EXTRACT(AnO(DATA_FATURA)) = 2007HAVING (COALESCE(IVA_FATURA;0) > 0)

CONCAT

CONCAT (expressão_aritmética, expressão_aritmética)

Descrição

A função CONCAT devolve as duas expressões passadas como parâmetros em forma de uma só cadeia concatenada.

Exemplo

Este exemplo devolve o nome e sobrenome como uma cadeia concatenada:

SELECT CONCAT(CONCAT(PESSOAS.Nome,' '), PESSOAS.Sobrenome) FROM PESSOAS;

CONCATENATE

CONCATENATE (expressão_aritmética, expressão_aritmética)

Descrição

A função CONCATENATE devolve as duas expressões passadas em parâmetros em forma de uma só cadeia concatenada.

Exemplo

Ver o exemplo da função CONCAT.

COS

COS (expressão_aritmética)

Descrição

A função COS devolve o cosseno da expressão_aritmética. A expressão_aritmética representa o ângulo expressado emradianos.

Exemplo

Este exemplo devolve o cosseno do ângulo expressado em radianos (graus * 180/3,1416):

SELECT COS(degrees * 180 / 3,1416)FROM TABLES_OF_ANGLES;

COT

COT (expressão_aritmética)

Descrição

A função COT devolve a cotangente da expressão_aritmética. A expressão_aritmética define um ângulo expressado emradianos.

Exemplo

Este exemplo devolve a cotangente do ângulo expressado em radianos (3,1416):

SELECT COT(3,1416)FROM TABLES_OF_ANGLES;

COUNT

COUNT ({ [ [ALL |DISTINCT] expressão_aritmética] |* } )

Descrição

A função COUNT devolve o número de valores no null presentes na expressão_aritmética. As palavras chaves opcionais ALL eDISTINCT permitem respectivamente incluir ou excluir os valores duplicados.Se passar o caractere *, a função devolve o número total de registros na expressão_aritmética, incluindo os valores NULL.

Exemplo

Este exemplo devolve o número total de filmes na tabela FILMES:

SELECT COUNT(*) FROM FILMES

CURDATE

CURDATE ( )

Descrição

A função CURDATE devolve a data atual.

Exemplo

Este exemplo cria uma tabela de faturas e insere a data atual na coluna DATA_FACT:

ARRAY STRING(30;aDate;0) Begin SQL CREATE TABLE INVOICES (DATE_FACT VARCHAR(40)); INSERT INTO INVOICES (DATE_FACT) VALUES (CURDATE()); SELECT * FROM FATURAS INTO :aDate; End SQL `o array aDate devolve a data e a hora de execução do comando INSERT.

CURRENT_DATE

CURRENT_DATE ( )

Descrição

A função CURRENT_DATE devolve a data local atual.

Exemplo

Este exemplo cria uma tabela de faturas e insere a data atual na coluna DATA_FACT:

ARRAY STRING(30;aDate;0) Begin SQL CREATE TABLE INVOICES (INV_DATE VARCHAR(40)); INSERT INTO INVOICES (INV_DATE) VALUES (CURRENT_DATE()); SELECT * FROM INVOICES INTO :aDate; End SQL `o array aDate devolve a data e a hora de execução do comando INSERT.

CURRENT_TIME

CURRENT_TIME ( )

Descrição

A função CURRENT_TIME devolve a hora local atual.

Exemplo

Este exemplo cria uma tabela de faturas é inserida a hora atual na coluna HORA_FACT:

ARRAY STRING(30;aDate;0) Begin SQL CREATE TABLE INVOICES (INV_DATE VARCHAR(40)); INSERT INTO INVOICES (INV_DATE) VALUES (CURRENT_TIME()); SELECT * FROM INVOICES INTO :aDate; End SQL `o array aDate devolve a hora de execução do comando INSERT.

CURRENT_TIMESTAMP

CURRENT_TIMESTAMP ( )

Descrição

A função CURRENT_TIMESTAMP devolve a data e a hora local atual.

Exemplo

Este exemplo cria uma tabela de faturas e insere a data e as horas atuais na coluna DATAHORA_FACT:

ARRAY STRING(30;aDate;0) Begin SQL CREATE TABLE INVOICES (DATAHORA_FACT VARCHAR(40)); INSERT INTO INVOICES (DATAHORA_FACT) VALUES (CURRENT_TIMESTAMP()); SELECT * FROM INVOICES INTO :aDate; End SQL `O array aDate devolve a data e a hora de execução do comando INSERT.

CURTIME

CURTIME ( )

Descrição

A função CURTIME devolve a hora atual com uma precisão de um segundo.

Exemplo

Este exemplo cria uma tabela de faturas e insere a hora atual na coluna HORA_FACT:

ARRAY STRING(30;aDate;0) Begin SQL CREATE TABLE INVOICES (HORA_FACT VARCHAR(40)); INSERT INTO INVOICES (HORA_FACT) VALUES (CURTIME()); SELECT * FROM FATURAS INTO :aDate; End SQL `O array aDate devolve a hora de execução do comando INSERT.

DATABASE_PATH

DATABASE_PATH()

Descrição

A função DATABASE_PATH devolve a via de acesso completa da base atual. A base atual pode ser modificada utilizando ocomando USE DATABASE. Por padrão, a base atual é a base 4D principal.A via de acesso devolvida está em formato POSIX.

Exemplo

Vamos Supor que a base externa atual é chamada TestBase.4DB e está na pasta "C:MyDatabases". Depois da execução doseguinte código:

C_TEXT($vCrtDatabasePath) Begin SQL SELECT DATABASE_PATH() FROM _USER_SCHEMAS LIMIT 1 INTO :$vCrtDatabasePath; End SQL

... a variável vCrtDatabasePath irá conter "C:MyDatabasesTestBase.4DB”.

DATE_TO_CHAR

DATE_TO_CHAR (expressão_aritmética, expressão_aritmética)

Descrição

A função DATE_TO_CHAR devolve uma representação em forma de texto da data passada na primeira expressão_aritméticaem função do formato especificado na segunda expressão_aritmética. A primeira expressão_aritmética deve ser de tipoTimestamp ou Duration e a segunda deve ser de tipo de texto.

Os códigos de formato que podem ser utilizados são apresentados a continuação. Geralmente, se um código de formato começapor um caracter em maiúsculas e produz um zero, então o número será iniciado com um ou mais zeros quando seja o caso; casocontrário, não terá zeros a esquerda. Por exemplo, se dd retorna 7, depois Dd devolverá 07.

O uso de caracteres em maiúsculas e minúsculas nos códigos de formato os dias e meses será reproduzido nos resultadosdevolvidos. Por exemplo, passar "day" devolverá "segunda", passar "Day" devolverá "Segunda" e passar "DAY" devolverá"SEGUNDA".

am - am ou pm em função do valor da horapm - am ou pm em função do valor da horaam - am ou pm em função do valor da horapm - am ou pm em função do valor da hora

d - número do dia da semana (1-7)dd - número do dia do mês (1-31)ddd - número do dia do anoday - número do dia da semanady - nome abreviado do dia da semana em 3 letras

hh - hora em números, baseada em 12 horas (0-11)HH12 - hora em números, baseada em 12 horas (0-11)hh24 - hora em números, baseada em 24 horas (0-23)

J - dia Juliano

mi - minutos (0-59)mm - mês em números (0-12)

q - trimestre

ss - segundos (0-59)sss - milisegundos (0-999)

w - semana do mês (1-5)ww - semana do ano (1-53)

yy - anoyyyy - ano

[Qualquer texto] - o texto entre colchetes ([ ]) não é interpretado e é inserido como está 'espaço de caractere -.,:;'espaço' 'tab' - sedeixa tal qual, sem mudanças.

Exemplo

Este exemplo devolve a data de nascimento como um número de dia da semana (1-7):

SELECT DATE_TO_CHAR (Data_Nascimento,’d’)FROM EMPREGADOS;

DAY

DAY (expressão_aritmética)

Descrição

A função DAY devolve o dia do mês da data passada na expressão_aritmética.

Exemplo

Este exemplo devolve o dia do mês para a data "05-07-2007":

SELECT DAY(’05-07-2007’);`devolve 7

DAYNAME

DAYNAME (expressão_aritmética)

Descrição

A função DAYNAME devolve o nome do dia da semana para a data passada em expressão_aritmética.

Exemplo

Este exemplo devolve o nome do dia da semana para cada data de nascimento passada:

SELECT DAYNAME(Data_nascimento);

DAYOFMONTH

DAYOFMONTH (expressão_aritmética)

Descrição

A função DAYOFMONTH devolve o número do dia do mês (de 1 a 31) da data passada na expressão_aritmética.

Exemplo

Vamos supor que temos a tabela PESSOAS com um campo Data_Nascimento. O seguinte código permite obter o dia denascimento de cada pessoa na tabela PESSOAS:

SELECT DAYOFMONTH(Data_Nascimento)FROM PESSOAS;

DAYOFWEEK

DAYOFWEEK (expressão_aritmética)

Descrição

A função DAYOFWEEK devolve um número que representa o dia da semana (de 1 a 7, onde 1 é domingo e 7 é sábado) da datapassada na expressão_aritmética.

Exemplo

Vamos supor que temos a tabela PESSOAS com um campo Data_Nascimento. O seguinte código permite obter o dia dasemana da data de nascimento de cada pessoa armazenada na tabela PESSOAS:

SELECT DAYOFWEEK(Data_Nascimento)FROM PESSOAS;

DAYOFYEAR

DAYOFYEAR (expressão_aritmética)

Descrição

A função DAYOFYEAR devolve o número do dia do ano (de 1 a 366, onde 1 é primeiro de janeiro) da data passada naexpressão_aritmética.

Exemplo

Vamos supor que temos a tabela PESSOAS com um campo Data_Nascimento. O seguinte código permite obter o dia do ano dadata de nascimento de cada pessoa na tabela PESSOAS:

SELECT DAYOFYEAR(Data_Nascimento)FROM PESSOAS;

DEGREES

DEGREES (expressão_aritmética)

Descrição

A função DEGREES devolve o número de graus da expressão_aritmética. A expressão_aritmética representa o ânguloexpressado em radianos.

Exemplo

Este exemplo cria uma tabela e insere valores baseados nos números de graus do valor Pi:

CREATE TABLE Degrees_table (PI_value float);INSERT INTO Degrees_table VALUES(DEGREES(PI()));SELECT * FROM Degrees_table

EXP

EXP (expressão_aritmética)

Descrição

A função EXP devolve o valor exponencial da expressão_aritmética, ou seja, é elevado a potência x, "x" é o valor passado naexpressão_aritmética.

Exemplo

Este exemplo retorna e é elevado a 15:

SELECT EXP( 15 ); `retorna 3269017,3724721107

EXTRACT

EXTRACT ({YEAR | MONTH | DAY | HOUR | MINUTE | SECOND | MILLISECOND} FROM expressão_aritmética)

Descrição

A função EXTRACT devolve da expressão_aritmética a parte especificada pela palavra chave associada a função. Aexpressão_aritmética passada deve ser do tipo Timestamp.

Exemplo

Este exemplo devolve todos os números de fatura desde o mês de janeiro:

SELECT NUM_FATURAFROM FATURASWHERE EXTRACT(MONTH(DATA_FATURA)) = 1;

FLOOR

FLOOR (expressão_aritmética)

Descrição

A função FLOOR devolve o número inteiro maior que seja inferior ou igual a expressão_aritmética.

Exemplo

Este exemplo devolve o inteiro maior inferior ou igual a -20.9:

FLOOR (-20.9);`devolve -21

HOUR

HOUR (arithmetic_expression)

Descrição

A função HOUR devolve a parte "hora" de uma hora passada na expressão_aritmética. O valor devolvido vai de 0 a 23.

Exemplo

Imagine que temos a tabela FATURAS com um campo Hora_Entrega. Para mostrar a hora de entrega:

SELECT HOUR(Hora_Entrega)FROM FATURAS;

INSERT

INSERT (expressão_aritmética, expressão_aritmética, expressão_aritmética, expressão_aritmética)

Descrição

A função INSERT insere uma cadeia em outra em uma posição dada. A primeira expressão_aritmética passada é a cadeia dedestino. A segunda expressão_aritmética é o índice onde a cadeia passada na quarta expressão_aritmética será inserida e aterceira expressão_aritmética indica o número de caracteres a eliminar em um ponto de inserção dado.

Exemplo

Este exemplo vai inserir "Querido " em frente dos nomes na tabela PESSOAS:

SELECT INSERT (PESSOAS.Nome,0,0,’Querido ‘) FROM PESSOAS;

LEFT

LEFT (expressão_aritmética, expressão_aritmética)

Descrição

A função LEFT devolve a parte mais a esquerda da expressão_aritmética passada. A segunda expressão_aritmética indica onúmero de caracteres a devolver a partir dos extraídos da primeira expressão_aritmética indicada.

Exemplo

Este exemplo devolve os nomes e as duas primeiras letras dos sobrenomes da tabela PESSOAS:

SELECT Nome, LEFT(Sobrenome, 2)FROM PESSOAS;

LENGTH

LENGTH (expressão_aritmética)

Descrição

A função LENGTH devolve o número de caracteres da expressão_aritmética.

Exemplo

Este exemplo devolve o número de caracteres dos nomes dos produtos que pesam menos de 15 kg.

SELECT LENGTH (Nome)FROM PRODUTOSWHERE Peso < 15.00

LOCATE

LOCATE (expressão_aritmética, expressão_aritmética,expressão _aritmética)

LOCATE (expressão_aritmética, expressão_aritmética)

Descrição

A função LOCATE devolve a posição inicial da primeira ocorrência de uma expressão_aritmética que se encontra dentro de umsegundo expressão_aritmética. Também pode passar uma terceira expressão_aritmética para especificar a posição docaractere onde a pesquisa deve começar.

Exemplo

Este exemplo devolve a posição da primeira letra X que se encontra entre os sobrenomes da tabela PESSOAS:

SELECT Nome, LOCATE('X',Sobrenome)FROM PESSOAS;

LOG

LOG (expressão_aritmética)

Descrição

A função LOG devolve o logaritmo neperiano ou logaritmo natural da expressão_aritmética.

Exemplo

Este exemplo devolve o logaritmo neperiano de 50:

SELECT LOG( 50 );

LOG10

LOG10 (expressão_aritmética)

Descrição

A função LOG10 devolve o logaritmo decimal (logaritmo base 10) da expressão_aritmética.

Exemplo

Este exemplo devolve o logaritmo decimal do valor 50:

SELECT LOG10( 50 );

LOWER

LOWER (expressão_aritmética)

Descrição

A função LOWER devolve a cadeia expressão_aritmética com todos os caracteres convertidos em minúsculas.

Exemplo

Este exemplo devolve os nomes dos produtos em minúsculas:

SELECT LOWER (Nome)FROM PRODUTOS;

LTRIM

LTRIM (expressão_aritmética[, expressão_aritmética])

Descrição

A função LTRIM elimina os espaços vazios possíveis localizados no inicio da expressão_aritmética. Asegunda expressão_aritmética opcional permite designar os caracteres específicos a excluir no inicio da primeiraexpressão_aritmética.

Exemplo

Este exemplo exclui todo espaço localizado no inicio do nome dos produtos:

SELECT LTRIM(Nome)FROM PRODUTOS;

MAX

MAX (expressão_aritmética)

Descrição

A função MAX devolve o valor máximo da expressão_aritmética.

Exemplo

Ver os exemplos das funções SUM e AVG.

MILLISECOND

MILLISECOND (expressão_aritmética)

Descrição

A função MILLISECOND devolve a parte de milissegundos da hora passada em expressão_aritmética.

Exemplo

Vamos supor que temos a tabela FATURAS com um campo Hora_Entrega. Para mostrar os milissegundos da hora de entrega:

SELECT MILLISECOND(Hora_Entrega)FROM FATURAS;

MIN

MIN (expressão_aritmética)

Descrição

A função MIN devolve o valor mínimo da expressão_aritmética.

Exemplo

Ver os exemplos das funções SUM e AVG.

MINUTE

MINUTE (expressão_aritmética)

Descrição

A função MINUTE devolve a parte de minutos da hora passada em expressão_aritmética. O valor devolvido vai de 0 a 59.

Exemplo

Vamos supor que temos a tabela FATURAS com um campo Hora_Entrega. Para mostrar os minutos da hora de entrega:

SELECT MINUTE(Hora_Entrega)FROM FATURAS;

MOD

MOD (expressão_aritmética, expressão_aritmética)

Descrição

A função MOD devolve o resto da divisão da primeira expressão_aritmética dividida pela segunda expressão_aritmética.

Exemplo

Este exemplo devolve o resto da divisão de 3 entre 10:

MOD(10,3) `devolve 1

MONTH

MONTH (expressão_aritmética)

Descrição

A função MONTH devolve o número do mês (de 1 a 12) da data passada na expressão_aritmética.

Exemplo

Vamos supor que temos a tabela PESSOAS com um campo Data_Nascimento. Para obter o mês da data de nascimento decada pessoa:

SELECT MONTH(Data_Nascimento) FROM PESSOAS;

MONTHNAME

MONTHNAME (expressão_aritmética)

Descrição

A função MONTHNAME devolve o nome do mês da data passada na expressão_aritmética.

Exemplo

Este exemplo devolve o nome do mês de cada data de nascimento:

SELECT MONTHNAME(Data_Nascimento);

NULLIF

NULLIF (expressão_aritmética, expressão_aritmética)

Descrição

A função NULLIF devolve NULL se a primeira expressão_aritmética é igual a segunda. Caso contrário, se devolve o valor daprimeira expressão_aritmética. As duas expressões devem ser comparáveis.

Exemplo

Este exemplo devolve NULL se o total da fatura é 0:

NULLIF(FATURAS_TOTAL,0);

OCTET_LENGTH

OCTET_LENGTH (expressão_aritmética)

Descrição

A função OCTET_LENGTH devolve o número de bytes de expressão_aritmética, incluindo os possíveis espaços.

Exemplo

Este exemplo devolve o número de bytes para uma coluna de dados binários:

SELECT OCTET_LENGTH (MinhaCol_binaria)FROM MinhaTablaWHERE MinhaCol_binaria = '93FB';` devolve 2

PI

PI ( )

Descrição

A função PI devolve o valor da constante Pi.

Exemplo

Ver o exemplo da função DEGREES.

POSITION

POSITION (expressão_aritmética IN expressão_aritmética)

Descrição

A função POSITION devolve um valor indicando a posição da primeira expressão_aritmética dentro da segundaexpressão_aritmética. Se não encontra a cadeia, a função devolve zero.

Exemplo

Este exemplo devolve a posição inicial da palavra "York" em todos os sobrenomes na tabela PESSOAS:

SELECT Nome, POSITION('York’ IN Sobrenome)FROM PESSOAS;

POWER

POWER (expressão_aritmética, expressão_aritmética)

Descrição

A função POWER eleva a primeira expressão_aritmética passada a potência "x", onde "x" é a segunda expressão_aritméticapassada.

Exemplo

Este exemplo eleva cada valor a potência 3:

SELECT SourceValues, POWER(SourceValues, 3)FROM ValuesORDER BY SourceValues`devolve 8 para SourceValues = 2

QUARTER

QUARTER (expressão_aritmética)

Descrição

A função QUARTER devolve o trimestre do ano (de 1 a 4) no qual aparece a data passada em expressão_aritmética.

Exemplo

Vamos supor que temos a tabela PESSOAS com um campo Data_Nascimento. Para obter o trimestre da data de nascimento decada pessoa:

SELECT QUARTER(Data_Nascimento) FROM PESSOAS;

RADIANS

RADIANS (expressão_aritmética)

Descrição

A função RADIANS devolve o número de radianos da expressão_aritmética. A expressão_aritmética representa o ânguloexpressado em graus.

Exemplo

Este exemplo devolve o número de radianos de um ângulo de 30 graus:

RADIANS ( 30 );`devolve o valor 0,5236

RAND

RAND ([expressão_aritmética])

Descrição

A função RAND devolve um valor de tipo flotante aleatório entre 0 e 1. A expressão_aritmética opcional pode ser utilizada parapassar um valor chave.

Exemplo

Este exemplo insere os valores de ID gerados pela função RAND:

CREATE TABLE PESSOAS(ID INT32,Nome VARCHAR);

INSERT INTO PESSOAS(ID, Nome)VALUES(RAND, 'Francis');

REPEAT

REPEAT (expressão_aritmética, expressão_aritmética)

Descrição

A função REPEAT devolve a primeira expressão_aritmética repetido o número de vezes definido pela segundaexpressão_aritmética).

Exemplo

Este exemplo mostra como funciona:

SELECT REPEAT( 'repetir', 3 )` devolve 'repetirrepetirrepetir'

REPLACE

REPLACE (expressão_aritmética, expressão_aritmética, expressão_aritmética)

Descrição

A função REPLACE busca na primeira expressão_aritmética passada todas as ocorrências da segunda expressão_aritmética esubstitui cada ocorrência encontrada pela terceira expressão_aritmética passada. Se não encontra nenhuma ocorrência, aprimeira expressão_aritmética permanece igual.

Exemplo

Este exemplo substituirá a cadeia "Francos" por "Euros" na coluna Divisa:

SELECT Nom, REPLACE(Divisa, ‘Francos’, ‘Euros’) FROM PRODUTOS;

RIGHT

RIGHT (expressão_aritmética, expressão_aritmética)

Descrição

A função RIGHT devolve a parte mais à direita da expressão_aritmética. A segunda expressão_aritmética indica o número decaracteres a devolver a partir da direita da primeira expressão_aritmética.

Exemplo

Este exemplo devolve os nomes e os dois primeiros caracteres dos nomes da tabela PESSOAS:

SELECT Nome, RIGHT(Sobrenome, 2)FROM PESSOAS;

ROUND

ROUND (expressão_aritmética[, expressão_aritmética])

Descrição

A função ROUND aproxima o valor passado na primeira expressão_aritmética a "x" decimais (onde "x" é a segundaexpressão_aritmética opcional passada). Se não é passada a segunda expressão_aritmética, a expressão_aritmética seaproxima ao número inteiro más próximo.

Exemplo

Este exemplo aproxima o número de origem a dois números decimais:

ROUND (1234.1966, 2)`devolve1234.2000

RTRIM

RTRIM (expressão_aritmética[, expressão_aritmética])

Descrição

A função RTRIM exclui os possíveis espaços vazios localizados ao final da expressão_aritmética. A segundaexpressão_aritmética opcional permite designar os caracteres específicos a excluir ao final da primeira expressão_aritmética.

Exemplo

Este exemplo exclui todo espaço vazio do final dos nomes dos produtos:

SELECT RTRIM(Nome)FROM PRODUTOS;

SECOND

SECOND (expressão_aritmética)

Descrição

A função SECOND devolve a parte segundos (de 0 a 59) do tempo passado na expressão_aritmética.

Exemplo

Vamos supor que temos a tabela FATURAS com um campo Hora_Entrega. Para mostrar os segundos da hora de entrega:

SELECT SECOND(Hora_Entrega) FROM FATURAS;

SIGN

SIGN (expressão_aritmética)

Descrição

A função SIGN devolve o signo da expressão_aritmética (1 para um número positivo, -1 para um número negativo o 0).

Exemplo

Este exemplo devolve todas as quantidades negativas que se encontram na tabela FATURAS:

SELECT AMOUNTFROM FATURASWHERE SIGN(QUANTIDADE) = -1;

SIN

SIN (expressão_aritmética)

Descrição

A função SIN devolve o seno da expressão_aritmética. A expressão_aritmética representa o ângulo expressado em radianos.

Exemplo

Este exemplo devolve o seno do ângulo em radianos:

SELECT SIN(radians)FROM TABELAS_DE_ÂNGULOS;

SPACE

SPACE (expressão_aritmética)

Descrição

A função SPACE devolve uma cadeia de caracteres do número de espaços definido na expressão_aritmética. Se o valorda expressão_aritmética é menor de zero, se devolverá um valor NULL.

Exemplo

Este exemplo adiciona três espaços a frente dos sobrenomes da tabela PESSOAS:

SELECT CONCAT(SPACE(3),PESSOAS.Sobrenome) FROM PESSOAS;

SQRT

SQRT (expressão_aritmética)

Descrição

A função SQRT devolve a raíz quadrada da expressão_aritmética.

Exemplo

Este exemplo devolve a raíz quadrada do frete:

SELECT Frete, SQRT(Flete) AS "Raiz quadrada do frete"FROM Ordens

SUBSTRING

SUBSTRING (expressão_aritmética, expressão_aritmética, [expressão_aritmética])

Descrição

A função SUBSTRING devolve uma subcadeia da primeira expressão_aritmética passada. A segunda expressão_aritméticaindica a posição de inicio da subcadeia e a terceira expressão_aritmética opcional indica o número de parâmetros a devolver apartir da posição de inicio. Se a terceira expressão_aritmética se omite, a função devolverá todos os caracteres a partir daposição de indicada.

Exemplo

Este exemplo devolve 4 caracteres do nome da loja a partir do segundo caractere:

SELECT SUBSTRING(Nome_loja,2,4)FROM GeographyWHERE Nome_loja = 'Paris';

SUM

SUM ([ALL |DISTINCT] expressão_aritmética)

Descrição

A função SUM devolve a suma da expressão_aritmética. As palavras chaves opcionais ALL e DISTINCT permitemrespectivamente incluir ou excluir os possíveis valores duplicados.

Exemplo

Este exemplo devolve a suma das vendas esperadas menos a suma das vendas realizadas, como também a quantidade mínimae máxima de vendas realizadas multiplicada por 100 e dividida pelas vendas esperadas na tabela VENDEDORES:

SELECT MIN ( ( SALES * 100 ) / COTA ),MAX ( ( SALES * 100 ) / COTA ),SUM ( COTA ) - SUM ( SALES )FROM VENDEDORES

TAN

TAN (expressão_aritmética)

Descrição

A função TAN devolve a tangente da expressão_aritmética. A expressão_aritmética representa o ângulo expressado emradianos.

Exemplo

Este exemplo devolve a tangente do ângulo expressado em radianos:

SELECT TAN(radianos)FROM TABELAS_DE_ÂNGULOS;

TRANSLATE

TRANSLATE (expressão_aritmética, expressão_aritmética, expressão_aritmética)

Descrição

A função TRANSLATE devolve a primeira expressão_aritmética com todas as ocorrências de cada um dos caracterespassados na segunda expressão_aritmética substituídos por seus caracteres correspondentes passados na terceiraexpressão_aritmética.

A substituição se realiza caractere por caractere (por exemplo, o primeiro caractere da segunda expressão_aritmética sesubstitui cada vez que aparece na primeira expressão_aritmética pelo primeiro caractere da terceira expressão_aritmética eassim sucessivamente).

Se há menos caracteres na terceira expressão_aritmética que na segunda, todas as ocorrências de caracteres da segundaexpressão_aritmética que não tenham um caractere correspondente na terceira expressão_aritmética serão excluídos daprimeira expressão_aritmética (por exemplo, se a segunda expressão_aritmética tem cinco caracteres a procurar e a terceiraexpressão_aritmética só contém quatro caracteres de substituição, cada vez que o quinto caractere dasegunda expressão_aritmética se encontre na primeira expressão_aritmética, será eliminada do valor devolvido).

Exemplo

Este exemplo substitui todas as ocorrências de "a" por "1" e as ocorrências de "b" por "2":

TRANSLATE ('abcd', 'ab', '12')` devolve '12cd'

TRIM

TRIM ([[LEADING |TRAILING |BOTH] [expressão_aritmética] FROM]expressão_aritmética)

Descrição

A função TRIM suprime das extremidades da expressão_aritmética os espaços vazios ou caracteres especificados na primeiraexpressão_aritmética.

Pode passar LEADING para indicar que os espaços/caracteres devem ser eliminados ao princípio da expressão_aritméticaunicamente, TRAILING com o propósito de indicar os que devem ser eliminadas ao final da expressão ou BOTH para combinaras duas operações. Não passar nenhuma destas palavras chaves, equivale a passar BOTH (os espaços o caracteres serãoeliminados ao princípio e ao final da expressão_aritmética).

A primeira expressão_aritmética opcional passada indica os caracteres específicos a excluir individualmente da segundaexpressão_aritmética. Se omite, só se excluídos os espaços vazios.

Exemplo

Este exemplo apaga os espaços dos nomes dos produtos:

SELECT TRIM(Nome)FROM PRODUTOS;

TRUNC

TRUNC (expressão_aritmética[, expressão_aritmética])

Descrição

A função TRUNC devolve a primeira expressão_aritmética truncada em "x" cifras a direita do separador decimal, onde "x" é ovalor passado na segunda expressão_aritmética opcional. Se omitida a segunda expressão_aritmética, a primeiraexpressão_aritmética se trunca eliminando a parte decimal.

Exemplo

Esta função trunca o número passado a uma cifra depois do separador decimal:

TRUNC(2.42 , 1)`devolve 2.40

TRUNCATE

TRUNCATE (expressão_aritmética[, expressão_aritmética])

Descrição

A função TRUNCATE devolve a primeira expressão expressão_aritmética truncada em "x" cifras a direita do separador decimal,onde "x" é o valor passado na segunda expressão_aritmética opcional. Se a segunda expressão_aritmética não é passada, aprimeira expressão_aritmética é truncada eliminando os decimais.

Exemplo

Ver o exemplo da função TRUNC.

UPPER

UPPER (expressão_aritmética)

Descrição

A função UPPER devolve a expressão_aritmética passada como uma cadeia onde todos os caracteres estão em maiúsculas.

Exemplo

Este exemplo devolve os nomes dos produtos em maiúsculas:

SELECT UPPER (Nome)FROM PRODUCTS;

WEEK

WEEK (expressão_aritmética)

Descrição

A função WEEK devolve o número da semana do ano (valor entre 1 e 54) da data passada na expressão_aritmética. A semanacomeça o domingo e o primeiro de janeiro é sempre a primeira semana.

Exemplo

Este exemplo devolve um número que indica a semana do ano para cada data de nascimento passada:

SELECT WEEK(Data_nascimento);

YEAR

YEAR (expressão_aritmética)

Descrição

A função YEAR devolve a parte do ano da data passada na expressão_aritmética.

Exemplo

Vamos supor que temos a tabela PESSOAS com um campo Data_Nascimento. Para obter o ano da data de nascimento de cadapessoa:

SELECT YEAR(Data_Nascimento)FROM PESSOAS;

Anexos

Anexo A: Códigos de erros SQL

Anexo A: Códigos de erros SQL

O motor SQL de 4D devolve os erros específicos, listados a continuação. Estes erros podem ser interceptados utilizando ummétodo de gestão de erros instalado pelo comando ON ERR CALL.

Erros genéricos

1001 INVALID ARGUMENT1002 INVALID INTERNAL STATE1003 SQL SERVER IS NOT RUNNING1004 Access denied1005 FAILED TO LOCK SYNCHRONIZATION PRIMITIVE1006 FAILED TO UNLOCK SYNCHRONIZATION PRIMITIVE1007 SQL SERVER IS NOT AVAILABLE1008 COMPONENT BRIDGE IS NOT AVAILABLE1009 REMOTE SQL SERVER IS NOT AVAILABLE1010 EXECUTION INTERRUPTED BY USER

Erros semânticos

1101 Table '{key1}' does not exist in the database.1102 Column '{key1}' does not exist.1103 Table '{key1}' is not declared in the FROM clause.1104 Column name reference '{key1}' is ambiguous.1105 Table alias '{key1}' is the same as table name.1106 Duplicate table alias - '{key1}'.1107 Duplicate table in the FROM clause - '{key1}'.1108 Operation {key1} {key2} {key3} is not type safe.1109 Invalid ORDER BY index - {key1}.1110 Function {key1} expects one parameter, not {key2}.1111 Parameter {key1} of type {key2} in function call {key3} is not implicitly convertible to {key4}.1112 Unknown function - {key1}.1113 Division by zero.1114 Sorting by indexed item in the SELECT list is not allowed - ORDER BY item {key1}.1115 DISTINCT NOT ALLOWED1116 Nested aggregate functions are not allowed in the aggregate function {key1}.1117 Column function is not allowed.1118 Cannot mix column and scalar operations.1119 Invalid GROUP BY index - {key1}.1120 GROUP BY index is not allowed.1121 GROUP BY is not allowed with 'SELECT * FROM ...'.1122 HAVING is not an aggregate expression.1123 Column '{key1}' is not a grouping column and cannot be used in the ORDER BY clause.1124 Cannot mix {key1} and {key2} types in the IN predicate.1125 Escape sequence '{key1}' in the LIKE predicate is too long. It must be exactly one character.1126 Bad escape character - '{key1}'.1127 Unknown escape sequence - '{key1}'.1128 Column references from more than one query in aggregate function {key1} are not allowed.1129 Scalar item in the SELECT list is not allowed when GROUP BY clause is present.1130 Sub-query produces more than one column.1131 Subquery must return one row at the most but instead it returns {key1}.1132 INSERT value count {key1} does not match column count {key2}.1133 Duplicate column reference in the INSERT list - '{key1}'.1134 Column '{key1}' does not allow NULL values.1135 Duplicate column reference in the UPDATE list - '{key1}'.1136 Table '{key1}' already exists.1137 Duplicate column '{key1}' in the CREATE TABLE command.1138 DUPLICATE COLUMN IN COLUMN LIST1139 More than one primary key is not allowed.1140 Ambiguous foreign key name - '{key1}'.1141 Column count {key1} in the child table does not match column count {key2} in the parent table of the foreign key definition.1142 Column type mismatch in the foreign key definition. Cannot relate {key1} in child table to {key2} in parent table.1143 Failed to find matching column in parent table for '{key1}' column in child table.1144 UPDATE and DELETE constraints must be the same.1145 FOREIGN KEY DOES NOT EXIST1146 Invalid LIMIT value in SELECT command - {key1}.1147 Invalid OFFSET value in SELECT command - {key1}.1148 Primary key does not exist in table '{key1}'.1149 FAILED TO CREATE FOREIGN KEY1150 Column '{key1}' is not part of a primary key.1151 FIELD IS NOT UPDATEABLE1152 FOUND VIEW COLUMN1153 Bad data type length '{key1}'.1154 EXPECTED EXECUTE IMMEDIATE COMMAND1155 INDEX ALREADY EXISTS1156 Auto-increment option is not allowed for column '{key1}' of type {key2}.1157 SCHEMA ALREADY EXISTS1158 SCHEMA DOES NOT EXIST1159 Cannot drop system schema

1160 CHARACTER ENCODING NOT ALLOWED

Erros de implementação

1203 The functionality is not implemented. 1204 Failed to create record {key1}.1205 Failed to update field '{key1}'.1206 Failed to delete record '{key1}'.1207 NO MORE JOIN SEEDS POSSIBLE1208 FAILED TO CREATE TABLE1209 FAILED TO DROP TABLE1210 CANT BUILD BTREE FOR ZERO RECORDS1211 COMMAND COUNT GREATER THAN ALLOWED1212 FAILED TO CREATE DATABASE1213 FAILED TO DROP COLUMN1214 VALUE IS OUT OF BOUNDS1215 FAILED TO STOP SQL_SERVER1216 FAILED TO LOCALIZE1217 Failed to lock table for reading.1218 FAILED TO LOCK TABLE FOR WRITING1219 TABLE STRUCTURE STAMP CHANGED1220 FAILED TO LOAD RECORD1221 FAILED TO LOCK RECORD FOR WRITING1222 FAILED TO PUT SQL LOCK ON A TABLE1223 FAILED TO RETAIN COOPERATIVE TASK1224 FAILED TO LOAD INFILE

Erro de análises

1301 PARSING FAILED

Erros de acesso a linguagem runtime

1401 COMMAND NOT SPECIFIED1402 ALREADY LOGGED IN1403 SESSION DOES NOT EXIST1404 UNKNOWN BIND ENTITY1405 INCOMPATIBLE BIND ENTITIES1406 REQUEST RESULT NOT AVAILABLE1407 BINDING LOAD FAILED1408 COULD NOT RECOVER FROM PREVIOUS ERRORS1409 NO OPEN STATEMENT1410 RESULT EOF1411 BOUND VALUE IS NULL1412 STATEMENT ALREADY OPENED1413 FAILED TO GET PARAMETER VALUE1414 INCOMPATIBLE PARAMETER ENTITIES1415 Query parameter is either not allowed or was not provided.1416 COLUMN REFERENCE PARAMETERS FROM DIFFERENT TABLES1417 EMPTY STATEMENT1418 FAILED TO UPDATE VARIABLE1419 FAILED TO GET TABLE REFERENCE1420 FAILED TO GET TABLE CONTEXT1421 COLUMNS NOT ALLOWED1422 INVALID COMMAND COUNT1423 INTO CLAUSE NOT ALLOWED1424 EXECUTE IMMEDIATE NOT ALLOWED1425 ARRAY NOT ALLOWED IN EXECUTE IMMEDIATE1426 COLUMN NOT ALLOWED IN EXECUTE IMMEDIATE1427 NESTED BEGIN END SQL NOT ALLOWED1428 RESULT IS NOT A SELECTION1429 INTO ITEM IS NOT A VARIABLE1430 VARIABLE WAS NOT FOUND1431 PTR OF PTR NOT ALLOWED1432 POINTER OF UNKNOWN TYPE

Erros de análises de data

1501 SEPARATOR_EXPECTED1502 FAILED TO PARSE DAY OF MONTH1503 FAILED TO PARSE MONTH1504 FAILED TO PARSE YEAR1505 FAILED TO PARSE HOUR1506 FAILED TO PARSE MINUTE1507 FAILED TO PARSE SECOND1508 FAILED TO PARSE MILLISECOND1509 INVALID AM PM USAGE1510 FAILED TO PARSE TIME ZONE1511 UNEXPECTED CHARACTER1512 Failed to parse timestamp.1513 Failed to parse duration.1551 FAILED TO PARSE DATE FORMAT

Erros lexer

1601 NULL INPUT STRING1602 NON TERMINATED STRING1603 NON TERMINATED COMMENT1604 INVALID NUMBER1605 UNKNOWN START OF TOKEN1606 NON TERMINATED NAME/* closing ']' is missing1607 NO VALID TOKENS

Erros de validação - Erros de estado depois de erros diretos

1701 Failed to validate table '{key1}'.1702 Failed to validate FROM clause.1703 Failed to validate GROUP BY clause.1704 Failed to validate SELECT list.1705 Failed to validate WHERE clause.1706 Failed to validate ORDER BY clause.1707 Failed to validate HAVING clause.1708 Failed to validate COMPARISON predicate.1709 Failed to validate BETWEEN predicate.1710 Failed to validate IN predicate.1711 Failed to validate LIKE predicate.1712 Failed to validate ALL ANY predicate.1713 Failed to validate EXISTS predicate.1714 Failed to validate IS NULL predicate.1715 Failed to validate subquery.1716 Failed to validate SELECT item {key1}.1717 Failed to validate column '{key1}'.1718 Failed to validate function '{key1}'.1719 Failed to validate CASE expression.1720 Failed to validate command parameter.1721 Failed to validate function parameter {key1}.1722 Failed to validate INSERT item {key1}.1723 Failed to validate UPDATE item {key1}.1724 Failed to validate column list.1725 Failed to validate foreign key.1726 Failed to validate SELECT command.1727 Failed to validate INSERT command.1728 Failed to validate DELETE command.1729 Failed to validate UPDATE command.1730 Failed to validate CREATE TABLE command.1731 Failed to validate DROP TABLE command.1732 Failed to validate ALTER TABLE command.1733 Failed to validate CREATE INDEX command.1734 Failed to validate LOCK TABLE command.1735 Failed to calculate LIKE predicate pattern.

Erros de execução - Erros de estado depois de erros diretos

1801 Failed to execute SELECT command.1802 Failed to execute INSERT command.1803 Failed to execute DELETE command.1804 Failed to execute UPDATE command.1805 Failed to execute CREATE TABLE command.1806 Failed to execute DROP TABLE command.1807 Failed to execute CREATE DATABASE command.1808 Failed to execute ALTER TABLE command.1809 Failed to execute CREATE INDEX command.1810 Failed to execute DROP INDEX command.1811 Failed to execute LOCK TABLE command.1812 Failed to execute TRANSACTION command.1813 Failed to execute WHERE clause.1814 Failed to execute GROUP BY clause.1815 Failed to execute HAVING clause.1816 Failed to aggregate.1817 Failed to execute DISTINCT.1818 Failed to execute ORDER BY clause.1819 Failed to build DB4D query.1820 Failed to calculate comparison predicate.1821 Failed to execute subquery.1822 Failed to calculate BETWEEN predicate.1823 Failed to calculate IN predicate.1824 Failed to calculate ALL/ANY predicate.1825 Failed to calculate LIKE predicate.1826 Failed to calculate EXISTS predicate.1827 Failed to calculate NULL predicate.1828 Failed to perform arithmetic operation.1829 Failed to calculate function call '{key1}'.1830 Failed to calculate case expression.1831 Failed to calculate function parameter '{key1}'.1832 Failed to calculate 4D function call.1833 Failed to sort while executing ORDER BY clause.1834 Failed to calculate record hash.1835 Failed to compare records.1836 Failed to calculate INSERT value {key1}.1837 DB4D QUERY FAILED1838 FAILED TO EXECUTE ALTER SCHEMA COMMAND1839 FAILED TO EXECUTE GRANT COMMAND

Erros de cachê

2000 CACHEABLE NOT INITIALIZED2001 VALUE ALREADY CACHED2002 CACHED VALUE NOT FOUND2003 CACHE IS FULL2004 CACHING IS NOT POSSIBLE

Erros de protocolo

A B C D E F G H I L M N O P Q R S T U W Y

3000 HEADER NOT FOUND3001 UNKNOWN COMMAND3002 ALREADY LOGGED IN3003 NOT LOGGED IN3004 UNKNOWN OUTPUT MODE3005 INVALID STATEMENT ID3006 UNKNOWN DATA TYPE3007 STILL LOGGED IN3008 SOCKET READ ERROR3009 SOCKET WRITE ERROR3010 BASE64 DECODING ERROR3011 SESSION TIMEOUT3012 FETCH TIMESTAMP ALREADY EXISTS3013 BASE64 ENCODING ERROR3014 INVALID HEADER TERMINATOR3015 INVALID SESSION TICKET3016 HEADER TOO LONG3017 INVALID AGENT SIGNATURE3018 UNEXPECTED HEADER VALUE

Manual de SQL - Lista alfabética dos comandos

ABS ACOS ALTER SCHEMA ALTER TABLE ASCII ASIN ATAN ATAN2 AVG