A Ordem de Fabricação 43654 solicita a fabricação de 1000 peças do item 11020/868TX.

A Ordem de Fabricação 43655 solicita a fabricação de 1000 peças do item 11009/270, que são necessários para compor a ordem de fabricação anterior, então vamos fazer a entrega de material para esta Ordem de Produção, concluir as Ordens de Fabricação com perca de peças da Ordem de Fabricação 43654 (produto acabado) e acompanhar a movimentação do estoque.

Imagem 01: Item 11009/270, em produção, estoque = 0.

Imagem 02: Item 11009/270, produzido, estoque = 1000.

Imagem 03: Item 11020/868TX, em produção, estoque = 2200.

Imagem 04: Conclusão da Ordem de Fabricação com ajuste de quantidades para 900 peças.

Imagem 05: continuação da conclusão da Ordem de Fabricação com ajuste de quantidades para 900 peças.

Imagem 06: continuação da conclusão da Ordem de Fabricação com ajuste de quantidades para 900 peças.

Imagem 07: continuação da conclusão da Ordem de Fabricação com ajuste de quantidades para 900 peças.

Imagem 08: continuação da conclusão da Ordem de Fabricação com ajuste de quantidades para 900 peças.

Imagem 09: Item 11020/868TX, produzido, estoque = 3100, (Saldo anterior 2200 + Produzido 900 = 3100).

Imagem 10: Item 11009/270, voltou a saldo=0.

Considerações finais

Note que apesar de termos ajustados o total produzido do produto acabado para menos, o sistema entendeu que utilizamos o total que estava comprometido na Ordem de Fabricação dos produtos semiacabados, entendo assim como perda e não sendo necessário fazer ajuste algum no sistema.
Seguindo estes passos o sistema irá fazer todo o processo de industrialização e movimentação de estoque corretamente.

O post Processo de Controle de Produção e Movimentação de Estoque apareceu primeiro em AdmNet.

2 – Verificar se já estão cadastradas as operações fiscais de compras, vale lembrar que operações de compras (Entrada) sempre começa com os número 1, 2, e 3.

2.1 – Caso não estejam cadastradas clicar em incluir e preencher os campos destacados criteriosamente.

3 – Após a verificação das Operações Especiais, entrar no modulo de compras e escolher a opção compras.

3.1 – Ao entrar em compras clicar em incluir, conforme imagem abaixo:

3.2 – Preencher os campos em destaque, conforme imagem abaixo:

3.3 Preencher os dados dos itens conforme imagem abaixo:

4 – Confirmação de compra:

5 – Liberação de compras, nesta tela deve ser feita a análise financeira e a liberação financeira da compra clicando em liberar (1) e enviando a compra para o recebimento.

6 – Tela de recebimento de compra;

7 – Tela de conferencia de compra:

8 – Detalhes que devem ser acrescentados sobre o comportamento do sistema.
Estando o cadastro de produtos devidamente preenchido nos campos tipo de produto e quantidade mínima, quando da venda de um produto o mesmo atingir sua quantidade mínima de estoque o sistema irá lançar uma solicitação de compras, que ficara em compras – solicitação, a mesma deve ser aprovada e ira para compras- cotação, que segue como se fosse um processo de compras, ao concluir a cotação ela irá para compras- liberação.

A política 1564 também deve estar ativada para que o sistema gere as solicitações de compras automaticamente.

O post Tutorial Módulo de Compras apareceu primeiro em AdmNet.

2 – Depois de incluir, inserimos o número do pedido e do item que tem que sair na tag XPed, conforme figura 2;

3 – Repito o mesmo processo para incluir outros itens, como mostra a figura 3;

4 – Após gravar o pedido, sigo com ele até o faturamento e após gerar a NF, o arquivo XML sai como o XML em anexo.

O post Integração Notas Fiscais – Campo XPED apareceu primeiro em AdmNet.

No entanto todo logo tivemos um grande problema, todos nossos projetos deveriam ser seguros, o acesso das páginas criadas deveria ser apenas permitidas por usuários cadastrados.

Para isso precisamos executar dois passos; ver abaixo.

• Para previnir o cadastro de novos usuários adione o seguinte código no final do LocalSettings.php

• Garanta o funcionamento tentando cadastrar um novo usuário. Ao tentar executar esse cadastro você deverá receber uma mensagem de erro falando que o usuário não foi encotrado. Para alterar essa mensagem, faça o login redirecione seu navegador para o seguinte dominio: wiki.seudominio.com.br/index.php?title=MediaWiki:Nosuchuser&action=edit

E altere a mensagem para o que desejar.
Ex: Essa wiki é privada sendo assim não é possível cadastrar novos usuários; caso tenha alguma duvida ou deseja se cadastrar contate o Yuri.

• Previnindo usuários anônimos de ler os conteúdos publicados, para fazer isso adicione o codigo abaixo dentro do seu LocalSettings.php:

• Confira se está tudo funcionando corretamente fazendo o logout e tentando navegar pela sua wiki.

O post Restringindo bloqueando acessos de uma MediaWiki apareceu primeiro em AdmNet.

2 – No cadastro do produto alterar o Subgrupo para o Subgrupo criado, como no exemplo Subgrupo Especial;

3 – Ainda na tela de cadastro do produto usar o botão, conforme imagem em anexo, Liberar Acesso aos Subgrupos de Produtos, nessa função para liberar o acesso daquele Subgrupo em específico para cada usuário, um de cada vez;

4 – Após escolher o usuário, escolher o subgrupo, nesse caso o Subgrupo Especial;

Obs.: Nos testes feitos foi criado inclusive um novo usuário para liberar esse produto especial e também foi feito um teste com um usuário existente. Caso seja necessário solicite que o usuário em questão faça um Logout do sistema e acesse novamente para ter acesso ao subgrupo “Especial”.

E.T.: Alguns recursos são específicos para clientes que adquiram customização ou desenvolvimento.

O post Liberação de Acesso para Item/Produto/Serviço Exclusivo apareceu primeiro em AdmNet.

Esta Nota deve ser gerada de acordo com as regulamentações do Sefaz e serve para correções de algum valor de impostos que pode ter sido enviado errado para o cliente ou para a Sefaz.

Emissão de Nota Complementar passo-a-passo:

1° Passo:

Para emissão desta nota deve ser cadastrado um produto com o nome de “Nota Fiscal Complementar” ou algum nome similar.

2° Passo:

Após cadastrar o produto, é necessário abrir o Módulo de Controle Especial de Nota fiscal do Sisnet.
Este módulo está localizado no Módulo de Vendas/ Vendas.
Abrindo este Módulo é necessário incluir uma nova Nota fiscal em branco.
Para isso basta incluir a mesma CFOP que foi usada na nota fiscal de origem e incluir o mesmo parceiro da nota de origem, marcar a opção “Gera NF com o N° digitado” e digitar o número da nota fiscal.
É muito importante cadastrar corretamente os dados do Parceiro nestas notas, já que qualquer mudança causará rejeição por parte da Sefaz.
Também é necessário escrever no campo de “Observações” a qual nota se refere esta nota de Complemento e qual o imposto que está sendo corrigido.

Conforme a Imagem:

3° Passo:

Após incluir o Parceiro, é necessário incluir o produto “Nota Fiscal Complementar” na nota.
Para isso é só clicar no botão “Incluir” logo abaixo das informações do Parceiro e irá abrir uma nova tela com as informações a serem incluídas sobre o produto.
Nesta tela, após incluir o produto é necessário excluir todos os campos de impostos que por acaso estejam preenchidos e preencher somente a quantidade que será sempre 0, a unidade e o valor a ser complementado do imposto. Neste exemplo da imagem, foi um complemento de 5% no valor do IPI.
Após fazer esta inclusão, basta clicar no botão “Gravar”.

4° Passo:

Preencha as informações de Transportadora, se necessário, e mande gravar a Nota Fiscal. A nota fiscal foi gerada com sucesso.

5° Passo;

Após gravar a nota, é necessário gerar o xml da nota através do módulo de Nota fiscal Eletrônica.
Seguindo os procedimentos normais do módulo de Nota fiscal Eletrônica e enviando ela para a Sefaz através do botão “Criar e Enviar”. A nota foi enviada com sucesso.

O post Tutorial para Emissão de Nota Fiscal Complementar apareceu primeiro em AdmNet.

Tela CFOP .

Tela IPI

Tela ICMS

Portanto estas informações farão parte ou não do carimbo fiscal pois serão alimentadas na tela de Faturamento em especifico no campo CARIMBO FISCAL .

Qualquer coisa diferente disso é customização realizada para o cliente.

Devemos observar que a política 2024 diz respeito a colocar ou não uma informação adicional no campo OBSERVAÇÃO de cada item da nota fiscal.
Este campo observação do item da nota fiscal é obtido através do campo OBSERVAÇÃO do cadastro do produto.

A nova versão do módulo emissor NFE.EXE v.3.12 não verifica política , mas simplesmente coloca a informação no XML caso encontre a informação gravada no NETNFVDITENS (tabela dos itens da nota fiscal)

Portanto aconselhamos a todos os clientes que utilizem a v.3.12 do nfe a utilizar no mínimo a versão 6.7.2011.5 do SisNet.

O post Carimbo Fiscal apareceu primeiro em AdmNet.

2ª – Definir valor Maximo de compras para os usuários em: Painel de Controle – Usuários – no campo Limite Maximo Compras.

3ª – No caso de trabalhar com loja simplificada definir estoque de loja em: Painel de Controle – Dados Cadastrais – Loja – Estoque Loja.

4ª – Verificar no cadastro de parceiros a situação exata do tipo de empresa: em Cadastro – Tabelas – Parceiros.
Obs.: Esta informação é necessária para que o sistema faça os cálculos de impostos corretamente.

5ª – Criar operações para situações especiais de movimentação de estoque, como por exemplo inventario em: Estoque – Tabelas – Operações.

6ª – Ajustar contas gerenciais nas operações fiscais em: Estoque – Tabelas – Operações.

7ª – Para empresas que estão classificadas nos regime tributários lucro real ou presumido, criar as tabelas de PIS e COFINS, em: Estoque – Tabelas – PIS e Estoque – Tabelas  Cofins.

8ª – Ajustar o cadastro de produtos conforme item criado anteriormente, em: Estoque – Tabelas – Produtos, Itens e Serviços.

9ª- Ajustar itens de estoque em: Estoque – Controle de Estoque – Itens.
Obs.: Fazer o ajuste nos 03 (Três) botões indicados na imagem.

10ª – Ajustar as tabelas de Tipos de Contas, Grupo de Contas e Plano de Contas Gerencial, para que as informações dos relatórios gerenciais saiam corretamente, imagem abaixo:

O post Atribuições do Gerenciador do Sistema para Migração apareceu primeiro em AdmNet.

1 – Baixar o Tortoise SVN no link http://tortoisesvn.sourceforge.net/, nesse link também tem o pack para portugês do Brasil.

2 – Depois de baixado e instalado terá de reiniciar o windows para podermos começar o trabalho.

3 – Após reiniciado, vamos criar a nossa pasta local que servirá de repositório.

3.1-Abra o windows explorer, botão direito do mouse, nova pasta:

3.2-De a pasta o nome de RepositorioSVN por exmplo:

4 – Vamos agora configurar a nossa pasta como repositorio, mais antes, já que instalamos o pack para linguá portuguesa vamos alter a configuração para português:

4.1-Clique com o botão direito do mause em cima da pasta, escolha a opção TortoiseSVN depois a opção setings:

4.2-Aparecerá a tela abaixo:

4.3-Na guia Language: selecione Português:

Clique em Apply e depois em OK. Agora o seo TortoiseSVN está em portugês, vamos continuar.

5 – Configurando nossa pasta como repositorio local:

5.1-Clique com o botão direito do mouse na pasta que criamos anteriormente, depois em TortoiseSVN, depois em “Criar repositório aqui…”

5.2-Aparecerá uma tela perguntando o tipo de repositório, vamos deixar a que já está marcada “Sistema de Arquivos Nativo (FSFS)”

Após confirmar o tipo de repositório, aparecerá a tela abaixo confirmando a criação do repositório:

Pronto, nosso repositório está criado, so que não iremos trabalhar nessa pasta pois os repositórios SVN guardam os seus arquivos em um formato proprietário que não podemos usar, para trabalharmos nós precisamos fazer uma outra pasta para “obter” os arquivos do repositório, para isso fazemos o seguinte:

5.3-Criamos outra pasta (procedimento 3.1), de a ela um nome como “PastaDeTrabalho”

5.4-Vamos “linkar” essa pasta com o nosso repositório para obter os arquivos:
– Clique com o botão direito na pasta de trabalho e escolha SVN Obter:

– Aparecerá a tela abaixo:

– Nessa tela é que vamos linkar o nosso repositório, no campo URL do repositório colocamos o endereço do repositório criado anteriormente. (esse endereço pode ser copiado do windows explorer, no caso acima a pasta está em : C:\TrabalhoTutorial\RepositorioSVN). Para adicionar no campo URL é necessário colocar antes do endereço o formato file:///. No caso acima ficará assim: file:///C:/TrabalhoTutorial/RepositorioSVN

-Pronto, está criado o link para o repositório.

A partir de agora, os arquivos dessa pasta poderão ser submetidos clicando com o botão direito sobre ela e selecionando TortoiseSVN e depois Submeter, uma janela se abrirá e você poderá selecionar os arquivos que deseja submeter. (Será mostrado abaixo esse processo), lembre-se, nunca apague ou renomeie um arquivo obtido de um repositório subversion pelo Windows, sempre use o TortoiseSVN, caso isso ocorra, o banco de dados internos do subversion fica perdido e você poderá ter alguns problemas

Repare que a pasta ficou com um circulo verde, quer dizer que ela existe no servidor, quando ele tem um ‘+’ em azul ela será adicionada ao servidor no próximo ‘submeter’, quando ela tem um ‘!’ vermelho, ela foi modificado e a versão será atualizada no próximo ‘Submeter’, as mesmas caracteristicas servem para os arquivos também.

6- Agora que já temos a nossa pasta de trabalho e o repositório criado, vamos criar um documento na pasta de trabalho para ver o funcionamento do repositório com a utilização do TortoiseSVN.

6.1-Primeiro, vamos criar um documento qualquer, como exemplo vou criar um documento html pelo word mesmo e colocar na pasta de trabalho que criamos, depois de criarmos o documento inicial, vamos adiciona-lo ao nosso repositório, para isso, clique com o botão direito no documento criado, escolha TortoiseSVN depois adicionar:

6.2-Aparecerá a tela abaixo para você confirmar a operação:

6.3-Após confirmar a operação ele mostrará a tela abaixo confirmando que o arquivo foi adicionado com sucesso

6.5-Submetendo o arquivo ao repositório:
Clique com o botão direito do mouse no arquivo que desejamos submeter, depois em SVN Submeter:

6.6-Na próxima tela escolhemos os arquivos que queremos submeter para o repósitorio, no nossa caso apenas o arquivo tutorial.html:

6.7-Após confirmar, ele será enviado para o repositório, será mostrado a tela abaixo dizendo que o arquivo foi submetido com suceso e informando o numero da revisão:

6.8-O Arquivo ficará com a bolinha verde, isso quer dizer que ele existe no servidor e está na versão atual.

6.9-Toda a vez que alterarmos o arquivo em questão ele ficará com o ponto de exclamação (como na fig. Item 6.4), avisando que o arquivo foi alterado e sua versão atual ainda não está no repositório, para atualizar o arquivo no repositório devemos repetir os procedimentos de 6.5 a 6.8, ai teremos uma nova versão do arquivo no repositório.

7 – Para deletarmos um arquivo da pasta de trabalho e também do repósitorio, basta apenas selecionarmos a opção TortoiseSVN, depois excluir.

Esse é o funcionamento básico do TortoiseSVN, como criar um repositório (local ou uma pasta na internet), como criar a pasta de trabalho, fazer a ligação entre as duas pastas e como criar e enviar os arquivos para o repositório e atualizar o mesmo.
Existem várias opções no TortoiseSVN para a manipulação de pastas/arquivos, podemos voltar uma versão anterior do documento, comparar duas versões, alterar o nome do arquivo/pasta (lembre-se, altere o nome apenas pelo Tortoise, caso seja feito diretamente pelo Windows pode prejudicar o envio do docmento).

O TortoiseSVN apresenta várias outras opções como ilustrado abaixo:

O post Tutorial SVN apareceu primeiro em AdmNet.

Contrary to what its name seems to imply, SQL is used not only to query a database and manipulate its data, but also to define it. SQL actually consists of two areas: a Data Definition Language (DDL), including the commands for creating databases and tables; and a Data Manipulation Language (DML), including the query commands. The next two sections will explore these two distinct areas.

NOTE All of the SQL snippets presented in this chapter have been tested with InterBase 5 and 6.

SQL: The Data Definition Language

The DDL commands are generally used only when designing and maintaining a database;
they are not used directly by a client application. The starting point is the create database command, which has a very simple syntax: create database “mddb.gdb”;

This command creates a new database (in practice, a new InterBase GDB file) in the current directory or in the indicated path. In the above statement, notice the final semicolon, used as a command terminator by the InterBase console. The opposite operation is drop database, and you can also modify some of the creation parameters with alter database.

NOTE In general, client programs should not operate on metadata, an operation that in most organizations would compete with the database administrator’s responsibilities. I’ve added these calls to a simple Delphi program (called DdlSample) only to let you create new tables, indexes, and triggers in a sample database. You can use that example while reading the following sections. As an alternative, you can type the commands in the Windows Interactive SQL application.

Data Types

After creating the database, you can start adding tables to it with the create table command. In creating a table, you have to specify the data type of each field. SQL includes several data types, although it is less rich than Paradox and other local databases. Table 11.1 lists SQL standard data types and some other types available on most servers.

NOTE The TStringField class in Delphi can distinguish between char and varchar types, indicating the actual type in a property and fixing some the problems of using a char that’s not padded with trailing spaces in the where clause of an update statement.
Programmers who are used to Paradox and other local engines will probably notice the absence of a logical or Boolean type, of date and time fields (the date type in InterBase holds both date and time), and of an AutoInc type, which offers a common way to set up a unique ID in a table. The absence of a logical type can create a few problems when upsizing an existing application. As an alternative, you can use a smallint field with 0 and 1 values for True and False, or you can use a domain, as explained in the next section. An AutoInc type is present in some servers, such as Microsoft SQL Server, but not in InterBase. This type can be replaced by the use of a generator, as discussed in the book.

SQL: The Data Definition Language

Domains

Domains can be used to define a sort of custom data type on a server. A domain is based on an existing data type, possibly limited to a subset (as in a Pascal subrange type). A domain is a useful part of a database definition, as you can avoid repeating the same range check on several fields, and you can make the definition more readable at the same time.
As a simple example, if you have multiple tables with an address field, you can define a type for this field and then use this type wherever an address field is used:create domain AddressType as char(30);
The syntax of this statement also allows you to specify a default value and some constraints,with the same notation used when creating a table (as we’ll see in the next section). This is the complete definition of a Boolean domain: create domain boolean as smallint default 0 check (value between 0 and 1); Using and updating a domain (with the alter domain call) makes it particularly easy to update the default and checks of all the fields based on that domain at once. This is much easier than calling alter table for each of the tables involved.

Creating Tables

In the create table command, after the name of the new table, you indicate the definition of a number of columns (or fields) and some table constraints. Every column has a data type and some further parameters:
• not null indicates that a value for the field must always be present (this parameter is mandatory for primary keys or fields with unique values, as described below).
• default indicates the default value for the field, which can be any of the following: a given constant value, null, or user (the name of the user who has inserted the record).
• One or more constraints may be included, optionally with a name indicated by the constraint keyword. Possible constraints are primary key, unique (which indicates that every record must have a different value for this field), references (to refer to a field of another table), and check (to indicate a specific validity check).

Here is an example of the code you can use to create a table with simple customer information:

create table customer (cust_no integer not null primary key,firstname varchar(30) not null,lastname varchar(30) not null,address varchar(30),phone_number varchar(20));

In this example, we’ve used not null for the primary key and for the first and last name
fields, which cannot be left empty. The table constraints can include a primary key using
multiple fields, as in:

create table customers (cust_no integer not null,firstname varchar(30) not null,…primary key (cust_no, name));

NOTE The most important constraint is references, which allows you to define a foreign key for a field. A foreign key indicates that the value of the field refers to a key in another table (a master table). This relation makes the existence of the field in the master table mandatory. In other words, you cannot insert a record referring to a nonexistent master field; nor can you destroy this master field while other tables are referencing it.

Once you’ve created a table, you can remove it with the drop table command, an operation that might fail if the table has some constrained relations with other tables. Finally, you can use alter table to modify the table definition, removing or adding one or more fields and constraints. However, you cannot modify the size of a field (for example, a varchar field) and still keep the current contents of the table. You should move the contents of the resized field into temporary storage, drop the field, add a new one with the same name and a different size, and finally move back the data.

Indexes

The most important thing to keep in mind about indexes is that they are not relevant for the definition of the database and do not relate to the mathematical relational model. An index should be considered simply a suggestion to the DBMS on how to speed up data access.

In fact, you can always run a query indicating the sort order, which will be available independently from the indexes (although the RDBMS can generate a temporary index). Of course, defining and maintaining too many indexes might require a lot of time; if you don’t know exactly how the server will be affected, simply let the RDBMS create the indexes it needs. The creation of an index is based on the create index command:

create index cust_name on customers (name);

You can later remove the index by calling drop index. InterBase also allows you to use the alter index command to disable an index temporarily (with the inactive parameter) and reenable it (with the active parameter).

Views

Besides creating tables, the database allows you to define views of a table. A view is defined using a select statement and allows you to create persistent virtual tables mapped to the physical ones. From Delphi, views look exactly the same as tables.

Views are a handy way to access the result of a join many times, but they also allow you to limit the data that specific users are allowed to see (restricting access to sensitive data). When the select statement that defines a view is simple, the view can also be updated, actually updating the physical tables behind it; otherwise, if the select statement is complex, the view will be read-only.

SQL: The Data Manipulation Language

The SQL commands within the Data Manipulation Language are commonly used by programmers,so I’ll describe them in more detail. There are four main commands: select, insert, update, and delete. All these commands can be activated using a Query component,but only select returns a result set. For the others, you should open the query using the ExecSQL method instead of Open (or the Active property).

Select

The select statement is the most common and well-known SQL command; it’s used to extract data from one or more tables (or views) of a database. In its simplest form, the command is:

select <fields> from <table>

In the <fields> section, you can: indicate one or more fields of the table, separated by commas;
use the * symbol to indicate all the table fields at once; or even specify an operation to apply to one or more fields. Here is a more complex example:

select upper(name), (lastname || “,” || firstname) as fullname
from customers

In this code, upper is a server function that converts all the characters to uppercase, the double-pipe symbol (||) is the string-chaining operator, and the optional as keyword gives a new name to the overall expression involving the first and last name.

By adding a where clause, you can use the select statement to specify which records to retrieve as well as which fields you are interested in:

select *
from customers
where cust_no = 100

This command selects a single record, the one corresponding to the customer whose ID number is 100. The where clause is followed by one or more selection criteria, which can be joined using the and, or, and not operators. Here is an  example:

select *
from customers
where cust_no=100 or cust_no=200

The selection criteria can contain functions available on the server and use standard operators,
including +, –, >, <, =, <>, >=, and <=. There are also few other special SQL operators:

is null Tests whether the value of the field is defined.
in <list> Returns True if the value is included in a list following the operator.
between <min> and <max> Indicates whether the value is included in the range.

Here is an example of these operators:

select *
from customers
where address is not null and cust_no between 100 and 150

Another powerful operator, used to perform pattern matching on strings, is like. For example,
if you want to look for all names starting with the letter B, you can use this statement:

select *
from employee
where last_name like “B%”
The % symbol indicates any combination of characters and can also be used in the middle of a
string. For example, this statement looks for all the names starting with B and ending with n:
select *
from employee
where upper(last_name) like “B%N”

The use of upper makes the search case-insensitive and is required because the like operator
performs a case-sensitive matching. An alternative to like is the use of the containing and starting with operators. Using like on an indexed field with InterBase might produce a very slow search, as the server won’t always use the index. If you are looking for a match in the initial portion of a string, it is better to use the starting with expression, which enables the index and is much faster.

Another option is to sort the information returned by the select statement by specifying an order by clause, using one or more of the selected fields:

select *
from employee
order by lastname

The asc and desc operators can be used for ascending and descending order; the default is ascending.
An important variation of the select command is given by the distinct clause, which removes duplicated entries from the result set. For example, you can see all the cities where you have customers with this expression:

select distinct city
from customer

The select command can also be used to extract aggregate values, computed by standard functions: avg Computes the average value of a column of the result set (works onlyfor a numeric field). count Computes the number of elements in the result set; that is, the number of elements satisfying the given condition. max and min Compute the highest and lowest values of a column in the result set. sum Computes the total of the values of a column of the result set. (It works only for numeric fields.) These functions are applied to the result set, usually to a specific column, excluding the null values. This statement computes the average salary:

select avg(salary)from employee

Another important clause is group by, which lets you aggregate the elements of the result set according to some criterion before computing aggregate values with the functions listed above. For example, you might want to determine the maximum and average salary of the employees of each department:

select max (salary), avg (salary), department from employee group by department Notice that all the noncalculated fields must appear in the group by clause. The following is not legal:
select max (salary), lastname, department from employee group by department

TIP When you extract aggregate values, it is better to use an alias for the result field with the as keyword. This makes it easier to refer to the resulting value in your Delphi code. The aggregate values can also be used to determine the records in the result set. The aggregate functions cannot be used in the where clause, but they are placed in a specific having section. The following statement returns the highest salary of each department, but only if the value is above 40,000:

select max(salary) as maxsal, department
from employee
group by department
having max(salary) > 40000

Another interesting possibility is to nest a select statement within another one, forming a subquery. Here is an example, used to return the highest-paid employee (or employees):

select firstname, lastname
from employee
where salary = (select max(salary) from employee)

 The Data Manipulation Language

We could not have written this code with a single statement, since adding the name in the query result would have implied adding it to the group by section as well. Inner and Outer Joins Up to now, our example select statements have worked on single tables—a serious limitation for a relational database. The operation of merging data from multiple source tables is called a table join. The SQL standard supports two types of joins, called inner and outer. An inner join can be written directly in the where clause:

select *
from <table1>, <table2>
where <table1.keyfield>=<table2.externalkey>

This is a typical example of an inner join used to extract all the fields of each table involved.
An inner join is handy for tables with a one-to-one relation (one record of a table corresponding only to one record of the second table). Actually, the standard syntax should be the following, although the two approaches usually generate the same effect:

select *
from <table1> left join <table2>
on <table1.keyfield>=<table2.externalkey>
An outer join, instead, can be specifically requested with the statement:
select *
from <table1> left outer join <table2>
on <table1.keyfield>=<table2.keyfield>

The main difference from an inner join is that the selected rows of an outer join will not consider the null fields of the second table. There are other types of joins, including these:the self-join, in which a table merges with itself; the multi-join, which involves more than two tables; and the Cartesian product, a join with no where condition, which merges each row of a table with each row of the second one, usually producing a huge result set. The inner join is certainly the most common form.

Insert

The insert command is used to add new rows to a table or an updateable view. When you insert a new record in a DBGrid connected with a SQL server table, the BDE generates an insert command and sends it to the server. Besides this implicit use, there are several cases in which you’ll want to write explicit SQL insert calls (including the use of cached updates, which we’ll discuss later in this chapter).

Unless you add a value for each field, you should list the names of the fields you are actually providing, as in the following code:

insert into employee (empno, lastname, firstname, salary)
values (0,”brown”, “john”, 10000)

You can also insert in a table the result set of a select statement (if the fields of the target table have the same structure of the selected fields), with this syntax:

insert into <table> <select statement>

Update

The update command modifies one or more records of a table or view. Delphi generates an update call every time you edit data with visual controls connected to a table or a live query on a SQL server. Again, there are also cases where you’ll want to use the update statement directly.

In an update statement, you can indicate which record to modify, by using a where condition similar to that of a select statement. For example, you can change the salary of a specific employee with this call:

update employee
set salary = 30000
where emp_id = 100

WARNING A single update instruction can update all the records that satisfy a given condition. An incorrect where clause could unintentionally update many records, and no error message would be displayed.

The set clause can indicate multiple fields, separated by commas, and it can use the current values of the fields to compute the new values. For example, the following statement gives a nice raise to the employees hired before January 1, 1990:

update employee
set salary = salary * 1.20
where hiredate < “01-01-1990”

Delete

The delete command is equally simple (although its misuse can be quite dangerous). Again, you generally remove records using a visual component, but you can also issue a SQL command like the following:

delete from employee
where empid = 120

SQL: The Data Manipulation Language

You simply indicate a condition identifying the records to delete. If you issue this SQL command with a Query component (calling ExecSQL), you can then use the RowsAffected property to see how many records were deleted. The same applies to the update commands.

Building Queries Visually in Delphi (with SQL Builder)

As we’ve seen, SQL has a great many commands, particularly in relation to select statements. And we haven’t actually seen them all! While the DDL commands are generally used by a database administrator, or only for the initial definition of the database, DML commands are commonly used in everyday Delphi programming work.

To help with the development of correct SQL statements, Delphi Enterprise includes a tool called SQL Builder, which unfortunately can be used only through a BDE connection (even if you can later copy the query and use it, for example, with a dbExpress dataset). You easily activate it by right-clicking a Query component.

Using SQL Builder is very simple. You choose the database you want to work on, and then you select one or more tables, placing them in the work area. After selecting the proper parameters, as explained below, you can use the command Query ➢ Run Query (or F9) to see the result of the query or the command Query ➢ Show SQL (F7) to see the source code of the select statement you’ve generated.

In the selected tables, you can simply mark the fields you want to see in the result set. The check box near the name of the table selects all of its fields. But the real power of SQL Builder lies in two features. First, you can drag a field from one table onto another table to join them. The other powerful feature is the Query notebook, the multipage control at the bottom of the SQL Builder window. Here is a short description of each of the pages:

The Criteria page indicates the selection criteria of the where clause. By selecting one of the fields of the result table, you can indicate a comparison against a fixed value or another field, and you can use like, is null, between, and other operators. Using the local menu of the grid present in this page, you can also activate the exist operator or an entire SQL expression. This page allows you to combine multiple conditions with the and, or, and not operators, but it doesn’t allow you to specify a precedence among
these operators by adding parentheses.

The Selection page lists all the fields of the result set and allows you to give them an alias. With the local menu, you can also introduce aggregate functions (sum, count, and so on). Finally, the upper-left check box indicates the distinct condition.

The Grouping page corresponds to the group by clause. SQL Builder automatically groups all the fields that are used in the aggregate functions, as required by the SQL standard. The Group Criteria page corresponds to a having clause, which is available in conjunction with aggregate functions. The operations are similar to those of the Selection page and are activated by using the local menu.

The Sorting page corresponds to the order by clause. You simply select the field you want to sort and then select the ascending or descending sort. The Joins page is the last but probably the most powerful, as it allows you to define join conditions, beyond the simple dragging of a field from one table to another in the work area. This page allows you to fine-tune the join request by indicating its type (INNER or OUTER) and selecting conditions other than the equality test.

To better understand how to use the SQL Builder, we can build an actual example based on the sample InterBase database installed by Delphi (and corresponding to the LocalIB alias). The example is in the SqlBuilder directory and its form has a Query, a DataSource, and a DBGrid component, connected as usual. The DatabaseName property of the Query component is set to IBLocal, and right-clicking the component activates SQL Builder.

We want to create a query including the first and last name, department, title, and salary of each employee. This operation requires two joins. Choose the Employee, Department, and Job tables. Click the Dep_No field of the Department table and drag the cursor over the Dep_No field of the Employee table. Similarly, connect the Job table with the Employee table using the three fields Job_Code, Job_Grade, and Job_Country.

After creating the joins, select the fields you want to see in the result set: First_ Name, Last_Name, and Salary from the Employee table; Department from the Department table; and Job_Title from the Job table. Finally, move to the Sorting page of the Query notebook and select Department.Department from the Output Fields list to sort the result set by department.
The following should be the generated SQL:

select employee.first_name, employee.last_name, department.department,
job.job_title, employee.salary
from employee employee
inner join department department
on (department.dept_no = employee.dept_no)
inner join job job
on (job.job_code = employee.job_code)
and (job.job_grade = employee.job_grade)
and (job.job_country = employee.job_country)
order by department.department

SQL: The Data Manipulation Language

We might add an extra where clause to choose only the employee with a high salary. Simply move to the Selection page, select the Employee.Salary field, go to the column Operator >=, and type the value 100,000. Executing the query, you’ll see a limited number of records, and looking at the SQL source you’ll see the extra statement:

where employee.salary >= 100000

Finally, note that it is possible to export and import the SQL code from a plain text file. Simply by closing SQL Builder, you will also save the text of the query in the SQL property of the related Query component.

O post Essential SQL apareceu primeiro em AdmNet.