Apostila Delphi 2010

ÍNDICE

Aula 1 - Delphi ................................................................................................................ 4

Área de Trabalho............................................................................................................ 5

A Janela Principal .......................................................................................................... 6

A Paleta de Componente................................................................................................ 6

Os Formulários ............................................................................................................... 7

O Editor de Código (Unit) ............................................................................................. 8

O Object Inspector ......................................................................................................... 8

Arquivos que Compõem a Aplicação............................................................................ 9

Arquivos Gerados pela Compilação ........................................................................... 10

Exercícios....................................................................................................................... 10

Aula 2 - Programação Orientada a Objeto ................................................................ 12

Propriedade................................................................................................................. 12 Eventos ....................................................................................................................... 13 Métodos ...................................................................................................................... 15

Exercícios....................................................................................................................... 16

Aula 3 - Variáveis ......................................................................................................... 19

Variáveis de Entrada e Saída ...................................................................................... 20 Tipos de Variáveis ...................................................................................................... 20 Variáveis Globais e Locais ......................................................................................... 21 Tipos de Transformação ............................................................................................. 21

Exercícios....................................................................................................................... 22

Aula 4 - Condição e Decisão ........................................................................................ 23

Operadores Relacionais .............................................................................................. 23 Desvios Condicionais .................................................................................................... 24

Desvio Condicional Simples ...................................................................................... 24 Exercícios....................................................................................................................... 25

Aula 5 - Desvio Condicional Composto ...................................................................... 26

Operadores Lógicos...................................................................................................... 27

Operador Lógico: AND.............................................................................................. 27 Operador Lógico: OR ................................................................................................. 27 Operador Lógico: NOT .............................................................................................. 28

Exercícios....................................................................................................................... 28

Aula 6 - Estrutura de Controle com Múltipla Escolha ............................................. 29

Exercícios....................................................................................................................... 30

Aula 7 - Exercícios de Fixação..................................................................................... 31

Aula 8 - Laço de Repetição .......................................................................................... 32

Enquanto..................................................................................................................... 32 Repita.......................................................................................................................... 32 Para ............................................................................................................................. 33

Exercícios....................................................................................................................... 34

Aula 9 - Exercícios de Fixação..................................................................................... 35

Aula 10 - Banco de Dados ............................................................................................ 36

A Arquitetura de Acesso a Banco de Dados............................................................... 36 Componentes Básicos ................................................................................................... 37

A Página Data Access/BDE ....................................................................................... 37 A Página Data Controls .............................................................................................. 38

Acessando Banco de Dados: Uma Introdução ........................................................... 40

Exercícios....................................................................................................................... 41

Aula 11 - Database Desktop......................................................................................... 42

Tipos de Dados no Paradox ......................................................................................... 44

Abrindo uma Tabela Existente ................................................................................... 45 Exercícios....................................................................................................................... 47

Aula 12 - BDE Administrator...................................................................................... 49

Criando Alias.............................................................................................................. 49 Acessando Banco de Dados Via Delphi ...................................................................... 50

Adicionando os Campos da Tabela ............................................................................ 51 Salvar os Dados Cadastrados...................................................................................... 52

Exercícios....................................................................................................................... 55

Aula 13 - Consultas....................................................................................................... 56

Método Locate............................................................................................................ 56 Pesquisa Exata ............................................................................................................ 57 Pesquisa Mais Próxima (Parcial)................................................................................ 57 Método FindKey......................................................................................................... 58 Método FindNearest ................................................................................................... 58

Exercícios....................................................................................................................... 59

Aula 14 - Conexão Via ODBC ..................................................................................... 60

Conexão Via ODBC...................................................................................................... 60

Exemplo de Conexão via ODBC................................................................................ 60 Exercícios....................................................................................................................... 62

Aula 15 - Criando um Projeto com Conexão Via ODBC.......................................... 63

DELPHI

Profª Paula Félix Dias Dantas Página 4

Aula 1

Delphi

O Delphi é uma plataforma para desenvolvimento de sistemas para o ambiente Windows e WEB. Ele combina a facilidade de utilização de um ambiente de desenvolvimento visual, o poder de uma linguagem compilada orientada a objetos e uma tecnologia de ponta em banco de dados, além da implementação de sistemas para Internet.

A palavra Delphi teve origem no nome de uma antiga cidade Grega situada perto do

Monte Parnassus. Por isso, o seu símbolo é uma Athena. Delphi é uma poderosa linguagem de desenvolvimento rápido (RAD – Rappid Application Development) para ambientes Win3X(Versão 1.0) e Win9x/NT (demais versões). Foi concebido pela Borland/Inprise para ser uma opção ao Visual Basic da Microsoft.

Seu ambiente foi todo construído na própria linguagem do Delphi, o Object Pascal –

OP (Pascal Orientado a Objeto) e possui ferramentas de desenvolvimento, como templates e experts de aplicações e formulários, que aumentam muito a produtividade, facilitando a programação da aplicação. O produto vem em três versões: a Standard, a Professional, e a Enterprise.

Com o Delphi pode-se criar qualquer tipo de aplicativo, desde banco de dados até

controladores de dispositivos. O trabalho de criação de aplicativos baseia-se na utilização de componentes (mini-programas) customizáveis, na base do arrastar e soltar, ou então programando tudo direto em OP.

O Delphi também oferece ferramentas de desenvolvimento, tais como repositórios de

aplicações e forms, que lhe permitem criar e testar rapidamente o protótipo de suas aplicações.

CURIOSIDADES

• Delphi é o nome Delfos traduzido para o inglês. Delfos era uma espécie de apelido do deus grego da arte e da sabedoria, Apolo.

• As pronúncias “Delfi” e “Delfai” são análogas. A primeira forma, grega, é a corrente, a segunda é usada mais tecnicamente, principalmente pelos norte-americanos.

DELPHI


Para se programar em Windows, as duas linguagens mais conhecidas e utilizadas que são o Visual Basic, da Microsoft e o Delphi, que era produzido pela Borland e atualmente está sendo produzido pela Embarcadero. Mas o que faz do Delphi uma linguagem ímpar são as seguintes características:

• Ele é compilador real, ou seja, gera um executável puro. Isso faz com que o

Delphi seja mais rápido que outras linguagens. Ele utiliza-se de compiladores Borland Pascal e C++ anteriores;

• Disponibilidade de código-fonte da bibliotecas; • O delphi pode trabalhar com os seguintes banco de dados nativos: Oracle,

Sybase e Informix, Interbase, MySql, SQL Server para client/server e, Paradox, DBase, Fox Pro e Access arquitetura de rede simples, além de outros, via ODBC e ADO;

• O delphi usa recursos diretamente de banco de dados para internet; • A codificação visual do programa fica muito mais forte e clara, com a

utilização da linguagem Object Pascal.

Área de Trabalho

A mesa de trabalho do Delphi é composta dos seguintes itens:

O delphi oferece um ambiente visual de desenvolvimento rico e versátil. Os que nunca

usaram outro ambiente visual de desenvolvimento como o Delphi (Visual Basic, Visual C++, PowerBuilder, etc) podem estranhar inicialmente a organização visual do ambiente. Diferentemente de aplicativos comuns, como o Word e o Excel da Microsoft, o Delphi não é um aplicativo MDI (com uma janela principal capaz de conter várias janelas secundárias).

DELPHI


O ambiente do Delphi é composto por várias janelas independentes que podem ser sobrepostas e reorganizadas livremente na tela.

A Janela Principal

Na janela principal, localizada na parte de cima da tela, estão a Barra de Menus, a

Paleta de Componentes e a Barra de Ferramentas. A janela principal é uma janela comum, apesar de ter uma aparência diferente do normal. Portanto é possível minimizá-la, maximizá-la e move-la normalmente. Minimizar a janela principal, minimiza todas as outras janelas do Delphi – não é necessário minimizar ou fechar cada uma das outras janelas primeiro. Quando a janela principal do Delphi é fechada, naturalmente, todo o ambiente (o Delphi inteiro) é fechado.

A Paleta de Componente

A paleta de componentes é uma das partes mais utilizadas do Delphi. É a partir dessa

paleta que se pode escolher componentes e adicioná-los a formulários. A paleta de componentes é dividida em várias páginas. Cada página contém um conjunto de componentes relacionados.

As páginas mais usadas são a Standard (com componentes básicos, como botões e caixas de texto), Additional (com alguns componentes especiais), e as páginas Data Access e Data Controls (para acesso e manipulação de banco de dados). Para passar de uma página para outra, clique na “aba” correspondente, na parte de cima da paleta de componentes.

DELPHI


Abaixo, vemos a explicação de cada página da Barra de Objetos.

PÁGINA

GRUPO DE COMPONENTES

STANDARD

Componentes básico da interface com o Windows, Labels, Edit, Listbox, Combobox, RadioGroup, etc.

ADDITIONAL

Grupo adicional de componentes padrões, tais como BitBtn, SpeedButton, MaskEdit, Image, Shape, Bevel, etc.

WIN32

Componentes a serem utilizados em programas que serão rodados em 32 bits, tais como PageControl, ProgressBar, Animate, DateTimePicker.

DATA CONTROLS

Componentes especializados de banco de dados utilizados para exibir dados de banco de dados, tais como Grid de dados, dbNavigator.

DATA ACCESS

Componentes especializados para acesso de dados em um banco de dados, tais como DataSource.

BDE

Componentes especializados para acesso de dados em um banco de dados usando a tecnologia BDE da Borland, tais como Table, Query.

ADO

Componentes especializados para acesso de dados em um banco de dados usando a tecnologia ADO da Microsoft, tais como ADOTable.

QREPORT

Componentes para geração de relatório.

INTERNET

Componentes para criar programas integrados com a internet.

DIALOGS

Quadros de diálogos comuns do Windows que possuem uma aparência.

Os Formulários

Os formulários (e o código associado a eles, as Units) constituem o coração de um

aplicativo no Delphi. Quando você entra no Delphi, ou cria um novo projeto, um formulário vazio é criado automaticamente.

DELPHI


Os formulários são as partes visíveis de um aplicativo no Delphi. Neles são inseridos

componentes como botões, listas, etc. Formulários podem ser usado com muitas funções diferentes em um aplicativo, um formulário pode, por exemplo, ser desde a janela principal até uma pequena caixa de mensagem.

O Editor de Código (Unit)

A todo formulário, é associado um programa chamado de Unit, no Delphi que controla

como os componentes dos formulários reagem às ações do usuário (os eventos). As units são exibidas no Editor de Código (Code Editor). O editor de Código pode mostrar várias Units ao mesmo tempo. Pode-se mudar de uma Unit para outra, usando-se as abas na parte de cima da janela.

O Object Inspector

O object inspector (tradução literal: “inspetor de

objetos”) é usado para definir propriedades e eventos para os componentes. As listas de propriedades e eventos exibidas no Object Inspector mudam de acordo com o componente selecionado.

Outra função importante do Object Inspector é

selecionar componentes por nome. Uma lista com o nome e o tipo de todos os componentes do formulário ativo são exibidos na parte de cima do Object Inspector. Para selecionar um componente, basta escolher seu nome nessa lista. Para Exibir/Esconder o Object Inspector, use o comando Wiew Object Inspector, ou pressione F11.

DELPHI


Arquivos que Compõem a Aplicação

A criar uma aplicação no Delphi, o mesmo irá criar alguns arquivos, vejamos abaixo

quais são esses arquivos:

EXTENSÃO ARQUIVO

DEFINIÇÃO FUNÇÃO

.DPR Arquivo do Projeto Código fonte em Pascal do arquivo principal do projeto. Lista todos os formulários e units no projeto, e contém código de inicialização da aplicação. Criado quando o projeto é salvo.

.PAS Código fonte da Unit (Object Pascal)

Um arquivo .PAS é gerado por cada formulário que o projeto contém. Seu projeto pode conter um ou mais arquivos .PAS associados com algum formulário. Contem todas as declarações e procedimentos incluindo eventos de um formulário.

.DFM Arquivo gráfico do formulário

Arquivo binário que contém as propriedades do desenho de um formulário contido em um projeto. Um .DFM é gerado em companhia de um arquivo .PAS para cada formulário do projeto.

.OPT Arquivo de opções do projeto

Arquivo texto que contém a situação corrente das opções do projeto. Gerado com o primeiro salvamento e atualizado em subsequentes alterações feitas para as opções do projeto.

.RES Arquivo de Recursos do Compilador

Arquivo binário que contém o ícone, mensagens da aplicação e outros recursos usados pelo projeto.

.~DP Arquivo de Backup do Projeto

Gerado quando o projeto é salvo pela segunda vez.

.~PA Arquivo de Backup da Unit

Se um .PAS é alterado, este arquivo é gerado.

.~DF Backup do Arquivo gráfico do formulário

Se você abrir um .DFM no editor de código e fizer alguma alteração, este arquivo é gerado quando você salva o arquivo.

.DSK Situação da Área de Trabalho

Este arquivo armazena informações sobre a situação da área de trabalho especifica para o projeto em opções de ambiente (Options Environment).

Obs.: Devido a grande quantidade de arquivos de uma aplicação, cada projeto deve ser

montado em um diretório específico.

DELPHI


Arquivos Gerados pela Compilação

EXTENSÃO ARQUIVO

DEFINIÇÃO FUNÇÃO

.EXE Arquivo compilado executável

Este é um arquivo executável distribuível de sua aplicação. Este arquivo incorpora todos os arquivos .DCU gerados quando sua aplicação é compilada. O Arquivo .DCU não é necessário distribuir em sua aplicação.

.DCU Código objeto da Unit A compilação cria um arquivo .DCU para cada .PAS no projeto.

Obs.: Estes arquivos podem ser apagados para economizar espaço em disco.

Exercícios 1. O que é Delphi?

2. Qual a função do Object Inspector?

3. Quais são os arquivos gerados pela compilação? E quais os arquivos que compõem a aplicação?

4. O que são formulários?

DELPHI


5. 1º Programa: a) Na Barra de Objetos, Tecle em (Label) e, em seguida, tecle no form; b) Escreva a frase “Olá Mundo!”; c) Na Barra de Ferramentas, tecle em (Run), para rodar o programa. d) Ao rodar aparecerá a seguinte tela:

DELPHI


Aula 2

Programação Orientada a Objeto

Para manipular um objeto trabalhamos com esses três conceitos:

1. Propriedade 2. Evento 3. Método

Propriedade

Propriedade é o que estabelecem, quais são as suas características, elas controlam a forma como um componente se comporta e a sua aparência em uma aplicação. Observe que, no topo do Object Inspector há uma “pasta” escrita properties, que são, por exemplo:

Principais Propriedades

Propriedade

Descrição

Color Estabelece a cor do componente.

Enabled Determina se o componente deve estar acionado ou não, ou seja, se ele estará respondendo a eventos do mouse, teclado, etc.

Font Determina os atributos (cor, tamanho, estilo ou nome) do componente.

Height Estabelece o tamanho vertical de um componente ou objeto.

Hint Possibilita um help on-line, ou seja, se o cursor permanecer parado sobre o componente, a mensagem escrita nessa propriedade aparecerá no vídeo.

Left Estabelece a localização horizontal do componente no lado esquerdo do form.

Name Determina o nome da propriedade, que não deve conter espaços vazios.

TabOrder Indica a posição que assume um componente perante os demais form por exemplo, se o form conter 3 componentes, a ordem deles é a estabelecida por essa propriedade.

Top Estabelece a localização vertical do componente a partir do canto superior do form.

Visible Determina se o componente deverá estar visível quando da execução do programa.

Width Estabelece o tamanho horizontal do componente.

DELPHI


Propriedades Específicas para Label/Form/Button

PROPRIEDADE DESCRIÇÃO Caption Estabelece o conteúdo visual do componente. No caso do form, será o

texto da barra do título; do label, o nome visível dele e no Button, o que deverá estar escrito dentro dele.

Propriedades Específicas para Edit

PROPRIEDADE DESCRIÇÃO CharCase Se for normal, aceitará as letras como maiúsculas e minúsculas, conforme

for digitado, se for LowerCase, considerará todas as letras digitadas como minúsculas e UpperCase, como maiúsculas.

MaxLength Estabelece o tamanho máximo de caracteres que o edit irá aceitar. PasswordChar Determina o caractere que será usado se o campo for usado para digitação

de senha. Por exemplo, colocando #, quando for digitado um texto nesse edit, só aparecerá #.

Text Estabelece qual o texto que deverá estar contido dentro do edit.

Vejamos um exemplo de como podemos alterar uma propriedade de um objeto em tempo de execução do sistema:

PROPRIEDADE: [NomeDoObjeto].[Propriedade]: = Novo Valor;

Cada componente no Delphi apresenta um conjunto de propriedades que determinam o comportamento e a aparência do componente. Propriedades podem ser definidas durante o desenvolvimento, ou alteradas durante o tempo de execução.

Eventos

É a que estabelece o que faz o objeto, são ações de usuários ou ocorrências do sistema que um componente possa reconhecer, tal como um clique no mouse. Repare que ao lado das properties, existe outra “pasta” escrita Events. É ai que se firma o que o objeto irá fazer. Os eventos podem ser, por exemplo, para um campo Edit.

Os eventos determinam a parte dinâmica de um aplicativo. Eles definem como o aplicativo reage às ações do usuário (ou de outros componentes). Cada componente oferece um conjunto de eventos específicos.

Para cada evento, pode-se associar um trecho de código que é executado quando o evento acontece. O código para os eventos de todos os componentes em um formulário é armazenado na Unit.

DELPHI


Associando Código a um Evento

Os eventos disponíveis para um componente são listados na página Events do Object

Inspector Para muitos componentes, a lista de eventos é extensa. No entanto, somente poucos eventos são usados com frequência.

Há três formas básicas para adicionar eventos a um componente:

Clicar duas vezes no componente: isso altera o evento padrão do componente. O evento padrão é geralmente o mais usado. Para o componente Button, por exemplo, o evento padrão é OnClick, que ocorre quando o botão é clicado. O delphi mostra o Editor de Código, já com um “esqueleto” do código para o evento. Veja um exemplo desse esqueleto: Procedure Tform1.Button1Click(Sender:Tobject); Begin End;

Entre o begin e o end é digitado o código a ser executado quando o usuário clica no botão (o Delphi já posiciona o cursor nesse local automaticamente).

A maneira descrita aqui funciona somente para os eventos padrão dos componentes. Para adicionar código para qualquer outro evento, deve-se realizar uma das ações descritas a seguir.

Clicar duas vezes ao lado do evento desejado (no Object Inspector): mostra o código para o evento no Editor de código. A partir daí, pode-se proceder como antes para digitar o código associado ao evento.

Escolher um procedimento já definido para um evento: clique do lado direito do nome do evento, no Object Inspector e escolha o nome do procedimento da lista que aparece. Faça isso quando for necessário associar o mesmo código a eventos de componentes diferentes. (Se ainda não houver nenhum código definido para eventos no formulário, a lista aparece vazia).

Principais Eventos BUTTON

EVENTO DESCRIÇÃO OnClick Ocorre quando o usuário dá um clique sobre o componente. OnMouseMove Ocorre quando o usuário move o ponteiro do mouse, quando o ponteiro do

mouse estiver sobre o componente.

DELPHI


EDIT

EVENTO DESCRIÇÃO OnChange Ocorre quando um determinado valor de um objeto ou componente é alterado. OnKeyPress Ocorre quando o usuário pressiona uma única tecla de caractere. OnExit Ocorre quando o foco de input passa de um componente para outro.

FORM

EVENTO DESCRIÇÃO

OnActivate Ocorre toda vez que o form é ativado. OnClose Ocorre toda vez que o form é fechado. OnCloseQuery Ocorre antes que o form se feche. OnCreate Ocorre quando o form é criado.

Apagando Eventos

Pode-se apagar eventos definidos para um componente, para corrigir um erro no desenvolvimento, por exemplo. Um evento pode ser apagado em “dois níveis”. O evento pode ser simplesmente desligado de um componente, permanecendo ligado a outros componentes, ou pode ser removido inteiramente do código.

Para desligar um evento de um componente, selecione o componente e clique no lado

do evento a ser removido, no Object Inspector. Isso seleciona o nome do evento. Em seguida, apague (pressione DELETE e depois ENTER).

Para remover um evento inteiramente do código, apague todo o código dentro do

evento, deixando apenas o código gerado automaticamente pelo Delphi (a primeira linha, o begin e o end). Em seguida, salve o arquivo, ou compile o projeto. O delphi remove o evento e todas as ligações a esse evento.

Métodos Além de propriedades e eventos, um componente possui métodos. Estes são

procedimentos padrões para os objetos. Nos termos de programação, um método é uma procedure ou função declarada como parte de um objeto. Para se escrever um método use o esquema a seguir:

Métodos (basicamente) são operações oferecidas por componentes do Delphi. Os

métodos de um componente são acessíveis somente através de programação, são usados para ler ou alterar propriedades de um componente, ou para realizar tarefas especiais.

DELPHI


Para ver a lista de métodos oferecidos por um componente, você precisa usar o recurso de ajuda do Delphi (os métodos são listados no Object Inspector). Para isso, selecione o componente no formulário e pressione F1. Em seguida clique na opção Methods, na parte de cima da janela de ajuda. (Note que alguns componentes não oferecem nenhum método).

MÉTODO: [NomeDoObjeto].[Método];

Vejamos alguns métodos mais usados, exemplificados:

Método Close

Coloque um botão no formulário e na propriedade Caption escreva &Sair;

DICA O símbolo & quando colocado em um Caption, irá sublinhar a letra imediatamente posterior e esta funcionará como tecla de atalho juntamente com o ALT, ou seja, no exemplo abaixo, o botão será acionado ao digitar ALT+S;

Duplo clique no botão; Form1.Close; Ao rodar o programa (tecla Run ou F9), verifique que ao clicar no botão, o programa será fechado. Método Clear

Coloque um campo edit no formulário e apague as informações das propriedades Text (para deixar em branco); Coloque um botão e escreva no Caption “Limpar”; Edit1.clear; Edit1.Setfocus;

Ao rodar o programa (tecla Run ou F9), verifique que ao clicar no botão, ele limpará o

conteúdo do edit e depois setará o cursor no edit novamente.

Exercícios 1. O que são propriedades?

DELPHI


2. O que são métodos? 3. O que são eventos? 4. Quais os principais eventos do button? 5. Cite a propriedade que é comum para o label e o Button. 6. Crie uma nova aplicação no delphi e crie o seguinte programa: a) Insira um Button e um Label no Form b) digite a seguinte linha de código: procedure TForm1.Button1Click(Sender: TObject); Begin Label1.Caption:= ‘Colégio Adelia'; end; c) Execute o programa e veja o que aconteceu. 7. Crie uma nova aplicação no delphi e crie o seguinte programa: a) Insira um Button e um Label no Form b) digite a seguinte linha de código: procedure TForm1.Button1Click(Sender: TObject); begin form1.caption:='Principal'; button1.Enabled:=false; end;

DELPHI


c) Execute o programa e veja o que aconteceu. 8. Crie uma nova aplicação no delphi e crie o seguinte programa: a) Insira um Button, e um edit no Form b) digite a seguinte linha de código: procedure TForm1.Button1Click(Sender: TObject); begin Edit1.clear; Edit1.setfocus; End; c) Execute o programa e veja o que aconteceu.

DELPHI


Aula 3

Variáveis

Toda informação a ser processada (via memória RAM) por um computador por meio de um programa precisa ser previamente armazenada em memória. Geralmente é com a utilização de variáveis que isso acontece.

No ambiente de programação Delphi, também podem ser armazenados valores na

memória, em um componente que esteja sendo usado para trabalhar a entrada ou saída de uma determinada informação.

Uma variável é uma região da memória previamente identificada, a qual tem por

finalidade armazenar as informações de um programa temporariamente. Cada variável armazena apenas um valor por vez. Denomina-se valor um conteúdo armazenado de qualquer tipo.

O nome de uma variável é utilizado para sua identificação e posterior uso em um

programa. Sendo assim, é necessário estabelecer algumas regras de utilização de variáveis:

• Nomes de variável podem ser atribuídos com um ou mais caracteres; • O primeiro caractere não pode ser, em hipótese nenhuma, um número, sempre

deve ser uma letra;

• O nome de uma variável não pode ter espaços em branco;

• Não pode ser nome de variável uma palavra reservada a uma instrução ou identificador de uma linguagem de programação, bem como o nome de seus componentes;

• Não podem ser utilizados outros caracteres, a não ser letras e números, com

exceção do caractere underscore “_”, que pode ser utilizado para simular a separação de duas palavras, como: Nome_Aluno, que poderiam estar também escritas como NomeAluno.

Deve-se considerar que, dentro de um programa, uma variável pode exercer dois

papéis, sendo um de ação, quando é modificada ao longo de um programa para apresentar um determinado resultado, e o segundo de controle, em que pode ser “vigiada” e controlada durante a execução de um programa.

Todo dado a ser armazenado na memória de um computador por meio de uma variável

deve ser previamente declarado, ou seja, primeiro é necessário saber o seu tipo para depois fazer o seu armazenamento. Estando armazenado, o dado pode ser utilizado e manipulado a qualquer momento durante a execução do programa.

DELPHI


Variáveis de Entrada e Saída Variáveis de entrada:

• Armazenam as informações fornecidas por um meio externo. • Ex: Usuários ou discos.

Variáveis de Saída:

• Armazenam dados processados como resultados.

Exemplo: A B C= A + B

De acordo com a figura acima, A e B são variáveis de entrada e C é uma variável de saída.

Tipos de Variáveis Principais tipos de variáveis do Pascal/Delphi

TIPO

VALORES USOS

Integer

- 2.147.483.648 a +2.147.463.647 Utilizada para armazenar números inteiros.

Double 15 a 16 dígitos significativos Utilizada para armazenar números com casas decimais (tipo float).

String

1 a 2 GB Armazena caracteres.

Boolean

True ou False Para situações de verdadeiro ou falso.

TDateTime

Data e/ou Hora Para armazenar data e ou hora.

Byte

0 a 255 Utilizada para armazenar números Inteiros peq.

ShorInt

-128 a 128 Utilizada para armazenar números Inteiros peq.

Word

0 a 65535 Utilizada para armazenar números Inteiros peq.

2 5 7

DELPHI


TIPO

VALORES USOS

Char

1 caracter Utilizada para armazenar 1 caracter apenas.

Real

11 a 12 dígitos significativos Utilizada mais na época do Pascal para números com casas decimais.

Single 7 a 8 dígitos significativos Utilizada em poucos casos para números pequenos com casas decimais.

Extended 19 a 20 dígitos significativos Utilizada para números com casas decimais muito longos.

Comp

19 a 20 dígitos significativos Utilizada para números inteiros muito longos.

Currency 19 a 20 dígitos significativos com apenas 4 após a vírgula

Utilizada algumas vezes para armazenar dinheiro.

Variáveis Globais e Locais

A variável global pode ser utilizada em todas as procedures. Sua desvantagem é que ela ocupa muito lugar na memória sem desocupá-la (ela deve ser declarada acima do implementation).

A variável local só pode ser utilizada na procedure em que foi declarada, ocupando pouco espaço e desocupando a memória logo que ela deixa de ser utilizada.

Tipos de Transformação Abaixo, a tabela de transformação:

FUNÇÃO

EFEITO

IntToStr

Converte um número inteiro em uma string (texto).

StrToInt

Converte uma string (texto) em um número inteiro.

FloatToStr Converte um número em ponto flutuante (com casas decimais) em uma string (texto).

StrToFloat Converte uma representação string em um número de ponto flutuante (casas decimais).

DELPHI


Exercícios 1. O que são variáveis? 2. Explique: a) IntToStr__________________________________________________________________ ___________________________________________________________________________ b) StrToInt__________________________________________________________________ ___________________________________________________________________________ c) FloatToStr________________________________________________________________ ___________________________________________________________________________ d) StrToFloat________________________________________________________________ ___________________________________________________________________________ 3. Faça um programa que recebe 02 números inteiros e calcule a soma deles. 4. Faça um programa que leia o nome e o sobrenome de uma pessoa e apresente seu nome completo. 5. Faça um programa que leia uma temperatura em graus Celsius e apresentá-la convertida em graus Fahrenheit. A fórmula da conversão é F= (9* C+160)/5, no qual F é a temperatura em Fahrenheit e C é a temperatura em Celsius.

DELPHI


Aula 4

Condição e Decisão

Para que seja possível fazer um programa de computador tomar decisões, é necessário primeiramente imputar uma condição. Não são somente os computadores que agem segundo este critério. Os seres humanos também tomam decisões baseadas em condições que lhes são apresentadas. Imagine como exemplo um programa de computador que faça a leitura de quatro notas bimestrais de um determinado aluno, calcule a média e apresente-a. Até aqui, muito simples, mas além, de calcular e apresentar a média, o programa deve também informar se o aluno foi aprovado ou reprovado segundo a verificação de sua média (considere a média maior ou igual a seis). O programa deve verificar o valor da média (que é a condição, no caso, média maior ou igual a seis) do aluno para então toma uma decisão no sentido de apresentar apenas uma das mensagens indicadas: aprovado ou reprovado. Em hipótese nenhuma podem ser apresentadas ambas as mensagens. Neste contexto de apresentar apenas uma das duas mensagens estabelecidas está a definição de uma condição (média maior ou igual a seis) que implica na tomada de uma decisão e apresenta a mensagem mais adequada ao contexto avaliado. Assim sendo, se a condição de verificação da média (média maior ou igual a seis) for verdadeira, de ser apresentada a mensagem aprovado; caso contrário, deve aparecer a mensagem reprovado.

Operadores Relacionais A relação existente entre os dois elementos de uma condição consegue-se com a utilização dos operadores relacionais de acordo com a tabela seguinte:

Símbolo Significado = Igual a <> Diferente de > Maior que < Menor que >= Maior ou igual que <= Menor ou igual que

Assim sendo, são condições válidas as seguintes estruturas relacionais: A=B, A<>B, A>B, A<B, A>=B, A<=B, A=6, A<>6, A>6,A<6,A>=6,A<=6.

DELPHI


Desvios Condicionais

O desvio condicional está associado à utilização de decisões dentro de um programa de computador. Uma decisão a ser tomada pode ser verdadeira ou falsa. Se for verdadeira, pode ser executada uma determinada ação; se falsa, pode ou não se executada uma outra ação. Assim sendo, um desvio condicional pode ser simples ou composto.

Desvio Condicional Simples Um desvio condicional é simples quando há uma condição que desvia a execução do programa caso o resultado lógico avaliado seja verdadeiro. Se o resultado lógico avaliado for falso, nada acontece, e o programa simplesmente segue o fluxo de execução. Um desvio condicional simples é definido no ambiente de programação Delphi por meio de instrução If..Then, que tem a seguinte sintaxe: IF (condição) then <instrução executada quando a condição for verdadeira>; <instrução executada após a condição ser verdadeira e/ou falsa>; Se o resultado lógico da condição for verdadeiro, é executada a instrução que estiver posicionada após a instrução then. Se o resultado lógico da condição for falso, é executada a instrução que existir após o trecho de código considerado verdadeiro. Caso venha a existir mais de uma instrução a ser executada com a condição verdadeira para uma determinada condição, elas devem estar inseridas em um bloco delimitado pelas instruções begin e end. Note que é considerado um bloco o conjunto de instruções entre um begin e um end, conforme o exemplo seguinte:

If (condição) then begin <instrução 1 executada quando condição for verdadeira>; <instrução 2 executada quando condição for verdadeira>; <instrução 3 executada quando condição for verdadeira>; <instrução n executada quando condição for verdadeira>; end; <instrução executada após a condição ser verdadeira e/ou falsa>;

DELPHI


Exercícios

1. Faça um programa que receba dois valores numéricos inteiros. Depois some os valores e apresente o seu resultado, caso o valor somado seja maior que 10.

2. Faça um programa que receba dois valores numéricos inteiros, os quais

independentemente da ordem em que foram fornecidos, devem ser impressos na ordem crescente, ou seja se forem fornecidos 5 e 3, respectivamente, devem ser apresentados 3 e 5. O programa em questão deve fazer a troca dos valores entre as duas variáveis.

DELPHI


Aula 5

Desvio Condicional Composto

Agora veremos como fazer uso da instrução IF..then..else. Sendo a condição verdadeira, é executada a instrução que estiver posicionada entre as instruções IF..then e else. Sendo a condição falsa, é executada a instrução que estiver posicionada logo após a instrução else, como é indicado na seguinte sintaxe: IF (condição) then <instrução executada quando condição for verdadeira> else <instrução executada quando condição for falsa>; <instrução executada após condição ser verdadeira ou falsa>;

Caso seja necessário considerar mais de uma instrução para as condições verdadeira ou falsa, utiliza-se o conceito de delimitação de blocos por meio de instruções begin e end,como indicado em seguida: If (condição) then begin <instrução 1 executada quando condição for verdadeira> <instrução 2 executada quando condição for verdadeira> <instrução n executada quando condição for verdadeira> end else begin <instrução 1 executada quando condição for verdadeira>; <instrução 2 executada quando condição for verdadeira>; <instrução n executada quando condição for verdadeira>; end; <instrução executada após condição ser verdadeira ou falsa>;

Observe que, nos dois casos mostrados, qualquer instrução que precede a instrução else está escrita sem o (;) ponto-e-vírgula. Isso ocorre pelo fato de a instrução else se uma extensão da instrução IF..then, e sendo assim o final da condição ocorre após a definição da instrução else.

DELPHI


Operadores Lógicos Existem ocasiões em que é necessário trabalhar com o relacionamento de duas ou mais condições ao mesmo tempo na mesma instrução IF..then para que seja tomada uma decisão e sejam realizados testes múltiplos. Para estes casos é necessário trabalhar com os operadores lógicos, também conhecidos como booleanos. Os operadores lógicos são três: and, or e not. Em alguns casos, os operadores lógicos evitam a utilização de muitas instruções IF..then encadeadas.

Operador Lógico: AND O operador do tipo and é utilizado quando dois ou mais relacionamentos lógicos de uma determinada condição necessitam ser verdadeiros. Em seguida é apresentada a tabela da verdade para esse tipo de operador:

Condição 1 Condição2 Resultado Falsa Falsa Falso Verdadeira Falsa Falso Falsa Verdadeira Falso Verdadeira Verdadeira Verdadeiro

O operador and faz com que somente seja executada uma determinada operação se todas as condições mencionadas forem simultaneamente verdadeiras, gerando assim um resultado lógico verdadeiro.

Operador Lógico: OR O operador do tipo or é utilizado quando pelo menos um dos relacionamentos lógicos (quando houver mais de um relacionamento) de uma condição necessita ser verdadeiro. Em seguida observe a tabela da verdade para esse tipo de operador:

Condição 1 Condição2 Resultado Falsa Falsa Falso Verdadeira Falsa Verdadeiro Falsa Verdadeira Verdadeiro Verdadeira Verdadeira Verdadeiro

O operador or faz com que seja executada uma determinada operação se pelo menos uma das condições mencionadas gerar um resultado lógico verdadeiro.

DELPHI


Operador Lógico: NOT O operador not é utilizado quando é preciso estabelecer que uma determinada condição deve ser não-verdadeira ou não-falsa. O operador not inverte o estado lógico de uma condição. Em seguida é apresentada a tabela da verdade para esse tipo de operador:

Condição 1 Resultado Falso Verdadeira Verdadeira Falso

O operador not faz com que seja executada uma determinada operação invertendo o resultado lógico da condição.

Exercícios

1. Faça um programa que receba dois valores numéricos do tipo inteiro e efetue a adição desses valores. Caso o resultado obtido seja maior ou igual a 10, esse valor dever ser apresentado, somando-se a ele 5. Caso o resultado do valor somado não seja maior ou igual a 10, ele deve ser apresentado subtraindo 7.

2. Faça um programa que receba um valor numérico do tipo inteiro. Se este número

estiver no intervalo entre 20 e 90 mostrar a mensagem: “O valor está entre 20 e 90”, caso o valor não estiver dentro dessa faixa mostrar a mensagem: ”O valor não está entre 20 e 90”.

3. Faça um programa que receba o sexo de uma pessoa. Caso o sexo digitado seja

válido mostrar a mensagem “O seu sexo é válido”, caso contrário mostrar “O seu sexo é inválido”.

DELPHI


Aula 6

Estrutura de Controle com Múltipla Escolha Ao trabalhar com uma sequência grande de desvios condicionais encadeados ou mesmo sequenciais, é possível deixar o programa difícil de ser interpretado. Existe uma forma mais adequada e eficiente para atender a este tipo de situação, que é a estrutura de controle com múltipla escolha, denominada estrutura case..of, que tem a seguinte sintaxe: case <variável> of <opção 1>: <operação 1> <opção 2>: <operação 2> <opção n>: <operação n> else <operação> end; ou case <variável> of <opção 1>: begin <operação 1.1> <operação 1.2> <operação 1.n>

end; <opção 2>: begin <operação 2.1> <operação 2.2> <operação 2.n>

end; <opção n>: begin <operação n.1> <operação n.2> <operação n.n>

end; else <operação_else> end;

DELPHI


Exercícios

1. Faça um programa que receba um valor numérico do tipo inteiro que esteja entre 1 e 12. Em seguida o programa deverá apresentar o nome do mês correspondente ao valor informado. Caso seja informado um valor de um mês inexistente, o programa avisa ao usuário o erro cometido.

2. Faça um programa que receba a idade de um nadador e imprima sua categoria

seguindo as regras abaixo:

Idade Categoria

5 à 7 anos Infantil A

8 à 10 anos Infantil B

11 à 13 anos Juvenil A

14 à 17 anos Juvenil B 3. Faça um programa que receba uma nota do tipo inteiro, se a nota digitada for 0 mostrar a mensagem “horroroso” se a nota for de 1 a 3 mostrar a mensagem “Péssimo” , se a nota for de 4 a 5 mostrar a mensagem “regular” , se a nota for de 6 a 7 mostrar a mensagem “bom” se a nota for de 8 a 9 mostrar a mensagem “ótimo” e se a nota for 10 mostrar a mensagem “excelente”.

DELPHI


Aula 7

Exercícios de Fixação

1. Faça um programa que leia um valor inteiro qualquer positivo ou negativo e

apresentar o número lido como um valor positivo.

2. Faça um programa que leia quatro valores referentes a quatro notas escolares de um aluno e apresentar uma mensagem informando se o aluno foi aprovado ou reprovado. Para determinar a aprovação do aluno, considere a média escolar maior ou igual a 6. Apresentar junto das mensagens o valor da média do aluno.

3. Faça um programa que leia quatro valores inteiros e apresentar somente aqueles

que forem divisíveis por 2 e 3.

4. Faça um programa que leia um valor numérico inteiro que esteja na faixa de 1 a 9. O programa deve indicar uma das seguintes mensagens:”O valor está na faixa permitida”, caso o valor fornecido esteja entre 1 e 9, ou “O valor está fora da faixa permitida”, caso o valor seja menor que zero ou maior que nove.

5. Faça um programa que faça a leitura do nome e do sexo de uma pessoa. O

programa deve apresentar para o sexo masculino a mensagem “Ilmo. Sr” e para o sexo feminino a mensagem “Ilma. Sra.”. Apresentar também junto da saudação o nome informado.

6. Faça um programa que leia um valor inteiro e apresentar uma mensagem informando se o valor é par ou ímpar.

DELPHI


Aula 8

Laço de Repetição

Enquanto A estrutura de laço de repetição do tipo enquanto (while) faz um teste lógico no início de um laço de repetição, verificando se é permitido executar o trecho de instruções subordinadas a esse laço, enquanto a condição de controle do laço permanecer verdadeira. A estrutura de laço while..do tem seu funcionamento controlado por condição. Dessa forma é possível executar um determinado conjunto de instruções enquanto a condição verificada permanecer verdadeira. No momento em que essa condição se tornar falsa (e deve se tornar falsa em algum momento), o processamento de execução do laço é desviado para fora dele. Se a condição do laço for falsa logo no início, as suas instruções são ignoradas. Caso seja necessário executar mais de uma instrução para uma condição verdadeira dentro de um laço (o que é bastante comum), elas devem estar mencionadas dentro de um bloco definido com as instruções begin e end. Desta forma a instrução while..do deve ser escrita com a seguinte estrutura: while (condição) do begin <instruções executadas enquanto a condição for verdadeira> end;

Repita Essa estrutura faz um teste lógico no final de um looping. Por ser parecida com a while, a estrutura em questão é denominada repeat, utilizada com o conjuntos de instruções repeat..until. Seu funcionamento é controlado por decisão, porém esse tipo de looping executa um conjunto de instruções pelo menos uma vez antes de verificar a validade da condição estabelecida. Diferente da estrutura while, que executa somente um conjunto de instruções enquanto a condição é verdadeira. Desta forma repeat tem seu funcionamento em sentido contrário à while, pois sempre processa um conjunto de instruções, no mínimo uma vez, até que a condição se torne verdadeira. A instrução repeat..until deve ser escrita: repeat <repita a instrução 1 até condição ser verdadeira>; <repita a instrução 2 até condição ser verdadeira>; <repita a instrução 3 até condição ser verdadeira>; <repita a instrução n até condição ser verdadeira>; until (condição);

DELPHI


Para Foram apresentadas duas formas de elaborar loopings. Uma usando o conceito while e outra usando o conceito repeat. Com essas duas técnicas é possível elaborar rotinas que façam um looping um determinado número de vezes com a utilização de um contador (variáveis que executam um determinado número de vezes) ou mesmo de uma variável que aguarde a resposta do usuário. Independentemente da forma de tratamento, esta é denominada variável de controle. Existe uma outra forma que visa facilitar o uso de contadores finitos sem estruturas anteriores. Desta formas os loppings com while e repeat passam a ser utilizados quando não se conhece de antemão o número de vezes que uma determinada sequência de instruções deve ser executada. Os loopings que possuem um número finito de execuções podem ser processados pelo tipo for..do , que tem seu funcionamento controlado por variável de controle do tipo contador, podendo ser crescente ou decrescente, tendo como sintaxe para looping crescente: for <variável> := <início> to <fim> do <instruções>

ou tendo como sintaxe para looping decrescente: for <variável> := <início> downto <fim> do <instruções>

Caso exista mais de uma instrução para ser executada dentro do looping, elas devem estar inseridas em um bloco de instruções begin e end;

for <variável> := <início> to <fim> do begin <instruções 1> <instruções 2> <instruções n> end; ou for <variável> := <início> downto <fim> do begin <instruções 1> <instruções 2> <instruções n> end;

DELPHI


Exercícios

1. Faça um programa que receba um valor numérico inteiro e calcule o seu fatorial. 2. Faça um programa que receba um valor numérico inteiro e calcule a tabuada.

3. Faça um programa que escreva os 100 primeiros números pares.

DELPHI


Aula 9

Exercícios de Fixação

1. Faça um programa que apresente os quadrados dos números inteiros de 15 a 200. 2. Faça um programa que apresente o total da soma obtida dos cem primeiros

números inteiros (1 +2+3+4+5+6+7+ ... +97+98+99+ 100).

3. Faça um programa que apresente todos os valores numéricos inteiros ímpares situados na faixa de 0 a 20. Para verificar se o número é ímpar, dentro da malha fazer a verificação lógica dessa condição com a instrução IF ... then, perguntando se o número é ímpar. Sendo, mostre-o; não sendo, passe para o próximo passo.

4. Faça um programa que apresente todos os números divisíveis por 4 que sejam

menores que 200.

5. Faça um programa que apresente o somatório de todos os valores pares existentes entre a faixa numérica de 1 a 500.

6. Faça um programa que mostre os valores compreendidos entre 25 e 5.

DELPHI


Aula 10

Banco de Dados

A Arquitetura de Acesso a Banco de Dados

No Delphi, trabalha-se com banco de dados de duas maneiras: via SQL (Oracle, Sysbase, Informix, etc) ou registro-a-registro (Paradox, Dbase, etc). No entanto, ele permite que você trabalhe em SQL com banco de dados registro-a-registro e vice-versa.

O acesso à banco de dados é um dos pontos fortes do Delphi, utilizando a biblioteca

Borland Database Engine (BDE). Para usar o BDE do Delphi, basta utilizar algum dos componentes para acesso a banco de dados, não havendo necessidade de chamar diretamente suas funções.

Ambiente de Desenvolvimento do Delphi

Aplicativo Delphi

Borland Database Engine (BDE)

SQL Links

Interbase

Informix

Oracle

Sybase

DB2

Paradox

Access

FoxPro

DBase

Socket ODBC

Drivers ODBC

Banco de Dados Compatíveis com ODBC

DELPHI


O Delphi oferece recursos poderosos para a criação de aplicativos com acesso a banco de dados. Aplicativos criados no Delphi podem ter acesso a dezenas de tipos de banco de dados, locais ou remotos.

Para os bancos de dados mais populares, como Oracle, Sybase, Access, etc., o Delphi

oferece acesso nativo. Toda a comunicação entre o Delphi e esses SGBDS é feita internamente no ambiente do Delphi. O Acesso nativo é geralmente muito mais rápido.

Para banco de dados menos populares, o Delphi oferece acesso via ODBC (Open

database Connectivity). Praticamente todos os banco de dados profissionais são compatíveis com a tecnologia ODBC. Um banco de dados compatível com ODBC oferece drivers ODBC que podem ser instalados no Windows. Com o driver ODBC correspondente instalado, um banco de dados pode ser acessado facilmente a partir do Delphi (o acesso é bem mais lento que o acesso nativo, no entanto).

Todo o acesso à banco de dados a partir de um aplicativo Delphi, sejam esses bancos

remotos ou não, é feito através do BDE (Borland Database Engine). O BDE é uma interface padrão que gerencia a parte técnica por trás do acesso e manipulação de banco de dados.

Além disso, o BDE uniformiza a comunicação entre os aplicativos e os banco de

dados. Pode-se usar os mesmos componentes e comandos para acessar um banco de dados Oracle, ou um banco paradox, por exemplo.

Os bancos locais, como Paradox e dbase são acessados diretamente pelo BDE. Já os

bancos remotos SQL, como Oracle e Sybase, precisam também do driver SQL links, instalado automaticamente com o Delphi Client/Server. É esse driver que garante a uniformização do acesso à banco de dados SQL, gerando consultas SQL automaticamente, no dialeto de SQL usado pelo banco. Com o driver SQL links, é possível trabalhar com bancos SQL da mesma forma que com banco locais.

Componentes Básicos

Há dezenas de componentes no Delphi para o trabalho com banco de dados. São duas páginas das paletas de componentes exclusivamente dedicadas a banco de dados: as páginas Data Access e Data Controls.

A Página Data Access/BDE

A página Data Access/BDE contém os componentes usados para realizar a conexão aos bancos de dados e acessar suas informações. Os componentes mais importantes, e de longe os mais usados, são os três primeiros: Data Source (Data Access), Table (BDE) e Query (BDE).

A página Data Access

DELPHI


A página BDE Há vários outros componentes avançados usados, por exemplo, para a criação de aplicativos cliente/servidor. Veja a seguir uma descrição breve dos componentes mais importantes da página Data Access.

Componente

Descrição

Data Source

Funciona como um intermediário entre os componentes table e query da paleta data controls.

Table

Usado para realizar o acesso a tabelas de um banco de dados.

Query

Usado para realizar o acesso a tabelas geradas por consultas SQL.

BatchMove

Usado para mover grandes quantidades de dados de uma tabela para outra, para copiar tabelas inteiras, ou para converter tabelas de um tipo para outro.

A Página Data Controls

A página Data Controls contém componentes que podem ser ligados diretamente a campos e tabelas de um banco de dados. Muitos desses componentes são apenas versões mais poderosas dos componentes na página Standard.

A página Data Controls

DELPHI


Os componentes Dbedit e Dbmemo, por exemplo são equivalentes aos componentes Edit e Memo, mas com o recurso adicional de acesso a banco de dados. Veja a seguir uma descrição breve dos componentes mais importantes da página Data Controls.

Componente

Descrição

DBGrid

Exibe dados em formato de tabela. Este componente é usado geralmente para exibir os dados de um componente table ou query.

DBNavigator

Usado para navegar os registros de uma tabela, permitindo que dados sejam apagados, inseridos ou alterados.

DBText

Exibe o texto de um campo de forma não-editável. Semelhante a um componente label.

DBEdit

Exibe o texto de um campo e permite editá-lo. Semelhante a um componente edit.

DBMemo

Exibe o texto de um campo com várias linhas de texto (do tipo “BLOB” ou “Memo”). Semelhante a um componente memo.

DBImage

Exibe imagens armazenadas em um campo do tipo BLOB, ou “image”.

DBListBox

Exibe uma lista de itens a partir da qual, pode ser escolhido um valor para um campo. Semelhante ao componente listbox.

DBComboBox

Semelhante ao componente dblistbox, mas permite a digitação direta de um valor, além da escolha de um item listado. Semelhante ao componente combobox.

DBCheckBox

Exibe um checkbox que pode ser usado para exibir ou alterar o valor de um campo booleano.

DbRadioGroup

Exibe um conjunto de valores mutuamente exclusivos para um campo.

DBLookUpListBox

Exibe uma lista de itens extraída de outra tabela relacionada. Somente elementos da lista podem ser escolhidos. Tem a mesma aparência e o mesmo funcionamento básico do componente ListBox.

DELPHI


DBLookUpComboBox

Exibe uma lista de itens extraída de outra tabela relacionada. Pode-se digitar um valor diretamente. Tem a mesma aparência e o mesmo funcionamento básico do componente ComboBox.

Acessando Banco de Dados: Uma Introdução

O acesso à banco de dados a partir de um aplicativo no Delphi é baseado em três componentes básicos: DataSource, Table e Query. Os três componentes não-visuais. Eles não são exibidos durante a execução. Apenas controlam a conexão com o banco de dados e o processamento dos dados. A conexão com um banco de dados é geralmente feita através de um componente Table ou Query. Esses componentes são do tipo DataSet. Os DataSets são conjuntos de dados armazenados em formato de tabela (em linhas e colunas). Ambos os componentes Table e Query tem a propriedade DatabaseName, que indica o banco de dados associado ao componente. Um componente table é ligado a uma tabela de um banco de dados através de sua propriedade TableName. Um componente Query contém o texto de uma query em SQL. Essa query pode ser executada, gerando uma nova tabela de dados (temporária) como resultado. O componente DataSource é usado como um intermediário obrigatório entre os componentes Data Controls em um formulário, e os dados de um componente Table ou Query. A propriedade DataSet de um componente DataSource é usada para realizar a ligação entre os componentes. A maioria dos componentes da página Data Controls apresenta a propriedade DataSource, onde é especificado o componente DataSource a ser conectado ao componente. Os dados exibidos nos componentes Data Controls são lidos a partir do componente DataSource especificado.

DELPHI


Exercícios 1. Quais são as duas maneiras para se trabalhar com Banco de Dados no Delphi? 2. Quais são as paletas de componentes dedicadas para Banco de Dados? 3. Qual a função do Borland Database Engine? 4. Quais os componentes básicos para conexão com o Banco de Dados? 5. Explique: a) DBMemo_________________________________________________________________ ___________________________________________________________________________ b) DBEdit___________________________________________________________________ ___________________________________________________________________________ c) DBNavigator______________________________________________________________ ___________________________________________________________________________ d) DBGrid__________________________________________________________________ ___________________________________________________________________________

DELPHI


Aula 11

Database Desktop

O Database Desktop é fornecido com o Delphi e serve para construir novas tabelas de banco de dados, para modificar os campos em banco de dados que já existam, para visualizar informações de banco de dados, e para criar alias para origens de dados.

Abaixo podemos ver a tela inicial do Database Desktop.

O tipo de banco de dados nativo do Delphi é o Paradox.

Agora vamos construir nosso primeiro banco de dados. Vamos acompanhar passo a passo.

Como podemos ver, para criar uma nova tabela, clicamos no menu File -> New -> Table, depois é mostrado uma tela onde indicamos o tipo da tabela (Paradox7, Paradox5, Dbase, Access, SQL, etc...) como podemos ver na figura seguinte:

DELPHI


Como o tipo padrão é o Paradox 7 e o mesmo já vem selecionado, só precisamos clicar no botão OK e estaremos prontos para definir a estrutura interna do nosso banco de dados como mostra a figura a seguir:

Aqui nos temos a parte da definição da estrutura (nome do campo /Field Name, Tipo/Type,Tamanho/Size e Chave/Key) e as propriedades da tabela (Table properties). Definido a estrutura da tabela, agora só falta salvar nosso arquivo de banco de dados em nosso computador, para isso clique no botão Save AS..., que será solicitado o local e o nome do arquivo a ser gravado.

DELPHI


Na caixa “Salvar em” especifique o local onde o seu arquivo vai ser salvo, preste bastante atenção, pois você pode estar salvando o arquivo em um outro local, que não o do seu aplicativo. Na caixa “Nome do Arquivo”, digite o nome do arquivo para o qual você criou a estrutura.

Tipos de Dados no Paradox

TIPO TAMANHO DESCRIÇÃO

A - Alfanumérico 1 – 255 Campo do tipo alfanumérico contém strings que consiste em: letras, números, caracteres especiais e outros caracteres imprimíveis ASCII.

N – Numérico O campo do tipo numérico só pode conter números, que podem ser positivos ou negativos.

D – Data O campo do tipo Data pode conter datas no intervalo de 01/01/999 até 31/12/9999.

M – Memo 1 – 240 Use o campo memo se você for gravar textos longos no seu banco de dados.

L – Lógico Os campos lógicos contém apenas os valores true ou false.

$ - Dinheiro Corresponde ao tipo numérico, só que inclui o símbolo da moeda corrente antes dos números.

+ Autoincremento O campo do tipo autoincremento contém um inteiro longo não editável, isso quer dizer que não é possível alterar seu valor, pois o mesmo é atribuído de forma automática.

I – Inteiro Longo O campo do tipo inteiro longo contém números não fracionados que variam de –2147483648 até 2147483648.

T – hora (Time) O campo do tipo hora contém a hora do dia gravado em milisegundos desde a meia-noite limitados até 24 horas.

DELPHI


Vamos ver estes tipos na figura abaixo:

Esta lista surge toda vez que teclamos a barra de espaço no local tipo, ao invés de digitá-lo diretamente.

Abrindo uma Tabela Existente

Vejamos agora como fazer para abrir uma tabela já existente, de forma que possamos alterar sua estrutura, digitar dados, etc..

DELPHI


Após esse procedimento surge a tela seguinte:

Agora iremos procurar a tabela desejada e depois clicar em Abrir e a tabela surge como mostra a figura.

Apartir daqui podemos inserir dados, reestruturar a tabela entre outras diversas opções. Vejamos nos passos que se segue como proceder para digitar dados diretamente na tabela sem a necessidade da criação de uma aplicação em Delphi para isso.

Para digitarmos alguma informação, basta clicarmos em Table - Edit Data.

DELPHI


Como podemos ver, quando estamos no modo de edição, os ícones no canto superior ficam pressionados e o nome “Edit” aparece na barra de status.

Exercícios

1. Crie as seguintes tabelas:

Field Name Type Size Key Código + * Nome A 30 DataAdm. D Valetransporte L Salário $ Obs. M 50

Salve a tabela na pasta 3pdn\lp2\BD com o nome funcionários.DB.

DELPHI


Field Name Type Size Key Código + * Nome A 30 Endereço A 50 Telefone A 14

Salve a tabela na pasta 3pdn\lp2\BD com o nome agenda.DB.

2. Após criado as tabelas cadastrar no mínimo 5 registros em cada uma delas

DELPHI


Aula 12

BDE Administrator

O BDE permite a configuração do núcleo de acesso à base de dados e que também seja especificado um alias (apelido link ou atalho).

Alias é um link ou atalho feito para que possa ser indicado o caminho do banco de

dados;

Criando Alias Em iniciar/Programas/Borland Delphi/BDE Administrator. Object / New. Aparecerá a seguinte figura:

Como estamos trabalhando com o Paradox escolheremos a opção Standard e em seguinte clicamos em OK e aparecerá o nosso alias na paleta databases como mostra a figura a seguir:

DELPHI


Mudaremos o Nome dele de Standard 1 para o nome que quisermos por exemplo Teste na paleta Definition precisamos dar o PATH (Caminho do nosso banco de dados). Por exemplo se o meu banco de dados está na pasta C:\Sistema\Tabelas, o meu PATH ficará da seguinte forma:

Ao fechar o BDE ele pedirá para salvar o alias, clicaremos em yes e ele salvará o nosso alias, agora poderemos retornar para a nossa aplicação.

Acessando Banco de Dados Via Delphi

Para acessarmos um banco de dados em qualquer aplicação Delphi, necessitamos utilizar os componentes dedicados à conexão de banco de dados.

Como estamos trabalhando com Paradox para que possamos conectá-lo a aplicação em

Delphi devemos colocar no nosso form um Table e um DataSource.

DELPHI


Esses dois componentes não irão aparecer no formulário quando a aplicação for executada. Algumas propriedades desses componentes precisam ser alteradas para realizar a conexão com o banco de dados, vejamos: Componente Table Databasename: nessa propriedade colocaremos o nome do alias criado para o nosso banco de dados. Tablename: nessa propriedade colocaremos o nome da tabela a qual desejo utilizar do meu banco de dados. Active: habilitar essa propriedade para true, para que possamos ativar a tabela. Componente DataSource DataSet: nessa propriedade colocaremos o nome do componente table que configuramos o acesso ao banco de dados.

Adicionando os Campos da Tabela

Para acionar os campos utilizaremos o Fields Editor do componente Table. Basta dar duplo click no table, botão direito no componente opção Fields Editor e aparecerá a seguinte tela: Selecione add fields e clique em OK.

DELPHI


Todos os campos serão inseridos na lista.

Depois de inserido os campos da tabela, criaremos um formulário com os campos da tabela. Para criar esses formulários temos duas opções. A 1º opção seria inserimos os componentes para criação do formulário Ex: Dbedit e Label, não esquecendo que para que ele possa gravar as informações no banco terá que ser alterada algumas propriedades do Dbedit que são: DataField (Nome do campo) e Datasource. A 2º opção é no Fields do table selecionar todos os campos e arrastar para o formulário, assim ele montará a estrutura completa para seu possível cadastro.

Salvar os Dados Cadastrados Para salvar os possíveis dados que serão digitados no seu formulários, temos duas opções, são elas: DBNavigator É um conjunto de botões para navegar e executar ações no banco de dados.

DELPHI


Podemos alterar algumas propriedades desse componente como a ShowHints e o VisibleButtons;

VisibleButtons: seleciono quais botões que eu quero que apareça; ShowHints: Ativando essa opção para true ao passar com o mouse por cima do

navigator ele me fala o que o botão faz; Construindo os Botões de Navegação

A outra opção é você inserir buttons e programá-los para que possam gravar, excluir,

inserir no banco de dados.

Exemplos: Botão Novo procedure TForm1.Button1Click(Sender: TObject); begin Table1.insert; end; Botão Gravar procedure TForm1.Button1Click(Sender: TObject); begin Table1.post; end; Botão Cancelar procedure TForm1.Button1Click(Sender: TObject); begin Table1.cancel; end;

Primeiro Anterior

Próximo Último

Inserir

Excluir

Voltar

Editar

Gravar

Cancelar

DELPHI


Botão Excluir procedure TForm1.Button1Click(Sender: TObject); begin if messagedlg(‘Excluir?’,mtconfiration,[mbyes,mbno],0)= Mryes then Table1.delete; end; Botão Ir para o Primeiro Registro procedure TForm1.Button1Click(Sender: TObject); begin Table1.first; end; Botão Ir para o Próximo Registro procedure TForm1.Button1Click(Sender: TObject); begin Table1.next; end; Botão ir para o Último Registro procedure TForm1.Button1Click(Sender: TObject); begin Table1.last; end; Botão Anterior procedure TForm1.Button1Click(Sender: TObject); begin Table1.prior; end;

DELPHI


Exercícios 1. Criar os alias para as tabelas elaboradas na semana passada. (tabela funcionários e tabela agenda).

2. Será necessário criar dois alias um para cada tabela? Justifique. 3. Crie o formulário da tabela funcionário e da tabela agenda utilizando o dbnavigator. Insira no mínimo 3 registros. 4. Crie o formulário da tabela funcionário e da tabela agenda elaborando os botões de inserção, navegação, etc.. Insira no mínimo 3 registros.

DELPHI


Aula 13

Consultas

Método Locate

O método Locate é a maneira mais versátil e mais rápida de localizar registros em um DataSet. Com os argumentos do método Locate, você especifica o nome dos campos a serem consultados, o valor desejado para cada campo especificado e um conjunto de opções de localização (que pode ser vazio). Veja a seguir um exemplo de uma chamada ao método Locate:

TabClientes.Locate('Nome;Sobrenome', VarArrayOf(['Maria', 'S']),[loPartialKey]);

O exemplo localiza o primeiro registro da tabela TabClientes, com nome "Maria" e sobrenome começando com "S".

O primeiro parâmetro de Locate é uma lista de campos separados por ponto-e-vírgula,

entre aspas simples. O segundo parâmetro é um array especial que deve ser construído com o comando VarArrayOf (para o caso de uma pesquisa em mais de um campo). Os valores aqui devem "casar” com os campos especificados no primeiro parâmetro. O terceiro parâmetro especifica opções de procura.

Há duas opções de procura disponíveis para o método Locate:

LoPartialKey: Permite que os valores de procura especificados no segundo parâmetro sejam parciais (parte de um nome, por exemplo). loCaseInsensitive: Faz com que Locate ignore maiúsculas e minúsculas. Com essa opção "maria", "Maria" e "MARIA" são considerados iguais, por exemplo.

Se houver algum registro que case com os valores especificados, o método Locate retorna true e move o cursor para aquele registro. Se nenhum registro for encontrado, Locate retorna false.

Se a localização for baseada em apenas um campo, a sintaxe de Locate é mais simples.

Veja um exemplo, que localiza o cliente com código igual a 100.

TabClientes.Locate('Codigo', 100, []);

Existem dois tipos de pesquisas: Exatas: para pesquisas de códigos, onde a pesquisa irá achar o registro exatamente como foi pedido; Inexatas (Mais Próxima): para pesquisas de nomes, endereços, etc... onde será achado o registro imediatamente superior ao que foi pedido (caso não se tenha o que foi pedido).

DELPHI


Para Simplificar, veja um exemplo:

Pesquisa Exata Dê um duplo clique no botão pesquisar e escreva: If not table1.locate(‘código’, Edit1.text,[ ]) then Showmessage (‘Registro não encontrado’); Nesse caso, se a função Locate voltar false (o registro não for achado), aparecerá a mensagem, caso seja achado o registro pesquisado será destacado. Esse exemplo é de consulta exata, ou seja, será procurado o registro que seja igual ao estabelecido, se pedirmos 1 será procurado o registro 1.

Pesquisa Mais Próxima (Parcial) Para vermos uma pesquisa inexata, crie outro label, outro edit e outro botão para elaborar a pesquisa por nome. Dê um duplo clique nesse novo botão e escreva: Table1.indexfieldnames: =’Nm_Autor’; Table1.locate(‘Nm_Autor’,Edit2.text,[LoPartialKey,LoCaseInsensitive]) Locate com a opção LoPartialKey que procura o registro com as iniciais do que foi estabelecido, por exemplo, no BD, acima, se pedir um autor que comece com C. Quando o campo a ser preenchido permitir digitação em maiúsculas e minúsculas deve se usar: LoCaseInsensitive.

DELPHI


Método FindKey

O método FindKey permite procurar por um registro cujos valores dos campos indexados sejam os mesmos valores passados como parâmetro para o FindKey. Esse método retorna o valor booleano true, em caso de sucesso, ou false, em caso de falha na tentativa de encontrar tal registro. Em caso de sucesso, o cursor da tabela também avança para a posição do registro encontrado. Vejamos um exemplo:

Dê um duplo clique no botão pesquisar e escreva:

Table1.FindKey([Edit1.Text]);

Nesse caso, ele localiza o código que for digitado no edit, caso ele retorne false, ele não retornará nenhuma mensagem. Em caso afirmativo (true) o registrado pesquisado será destacado. Vejamos um exemplo com mensagem:

If Not Table1.FindKey([Edit1.Text]) then

ShowMessage('Registro não Encontrado'); Nesse caso, se a função FindKey voltar false (o registro não for achado), aparecerá a

mensagem, caso seja achado o registro pesquisado será destacado. Note que nos exemplos acima com a função FindKey somente trabalhamos com

consultas exatas.

Método FindNearest

O método FindNearest permite procurar registros parciais dentro de um campo chave ou indexado. Caso ele retorne true para a pesquisa feita ele irá trazer o registro mais próximo ao localizado. Caso ele não encontre nenhum registro ele retornará false. Esse tipo de pesquisa pode ser utilizada para procurar nomes, endereços, etc...

DELPHI


Note que o método locate pode efetuar pesquisas exatas e inexatas, o método FindKey só efetua pesquisas exatas e o método FindNearest pesquisas inexatas.

Vejamos um exemplo de pesquisa com o método FindNearest:

Para vermos uma pesquisa inexata, crie outra label, outro edit e outro botão para se pesquisar o nome. Dê um duplo clique nesse novo botão e escreva:

Table1.indexfieldnames: =’Nm_Autor’; Table1.FindNearest([Edit1.Text]);

Nesse caso, ele localiza o nome ou parte do nome que for digitado no edit, caso ele

retorne false, ele não retornará nenhuma mensagem. Em caso afirmativo (true) o registrado mais próximo será destacado.

Exercícios 1. Com base no exercício da aula passada, crie um novo formulário no cadastro de funcionários, aonde poderá ser feita uma pesquisa por nome ou por código. Utilizar o Método Locate. 2. Com base no exercício da aula passada, crie um novo formulário no cadastro agenda, aonde poderá ser feita uma pesquisa por nome, por endereço ou por telefone. Utilizar os métodos FindKey e FindNearest.

DELPHI


Aula 14

Conexão Via ODBC

O Delphi, é uma poderosa linguagem de programação que entre seus muitos recursos,

pode através de links SQL, acessar bancos de dados relacionais tais como: SQL Server, Oracle, InterBase, Informix Etc. Isto é feito através de três possibilidades : ODBC, BDE e ADO.

Iremos aprender agora como conectar um banco de dados via ODBC, pois é um modo

universal de acesso a dados. (pois nem todas as versões do Delphi possui a paleta ADO para conexão).

Exemplo de Conexão via ODBC

Vá até o painel de controle - ferramentas administrativas e escolha a opção fonte de dados (ODBC), duplo click nessa opção e aparecerá a seguinte tela:

Nesta tela iremos criar o alias do nosso banco de dados, isto é necessário para que na sua aplicação Delphi, você apenas diga aos seus componentes de acesso a dados, trabalhe com o banco “nome_alias”. Clique em adicionar e escolha o driver para o banco de dados, no nosso exemplo iremos conectar um banco Access então iremos escolher o Driver do Microsoft Access (*.mdb), clique em concluir e aparecerá a seguinte tela:

DELPHI


Na opção nome da fonte de dados você colocará o nome do alias. Em seguida, clicar no botão selecionar, ao clicar irá abrir uma outra janela aonde nos iremos localizar o banco de dados que gostaríamos de conectar. Depois basta clicar em OK

Após ter clicado em Ok ele retornará a tela inicial e mostrará a sua conexão nessa tela,

depois disso basta conectar o banco de dados no Delphi.

DELPHI


Agora criamos um novo projeto no delphi. Insira no form o componente database (Paleta BDE) duplo click no componente e aparecerá a seguinte tela:

Na opção alias name iremos escolher o nome do alias que criamos na conexão via ODBC no exemplo alias chama apostila. Na opção name iremos dar um nome que gostaríamos, por exemplo, teste. Clicaremos em OK e depois não esquecer de habilitar o connected para true. Após isso basta inserir um Table e um DataSource para que possamos comunicar com as tabelas do banco conectado.

Exercícios 1. Crie o banco de dados abaixo no Access. Depois de criado o banco crie uma conexão via ODBC para esse banco.

Campo Tipo Tamanho coddocliente Autonumeração nomedocliente Texto 100 nomedaempresa Texto 80 Nomedocontato Texto 30 cargodocontato Texto 50

Salve a tabela com o nome de cliente e o Banco de Dados como AULA_ODBC.mdb 2. Ao utilizar conexão via ODBC é necessário criar um alias no BDE? Justifique.

DELPHI


Aula 15

Criando um Projeto com Conexão Via ODBC

Projeto Farmácia

1. Criar as seguintes tabelas no Access:

Tabela Cliente Campo Tipo Tamanho Cod_cliente Autonumeração Nome Texto 100 Endereço Texto 80 Telefone Texto 14 CPF Texto 20 RG Texto 15 Cidade Texto 20

Tabela Farmácia

Campo Tipo Tamanho Cod_farm Autonumeração Nome Texto 100 CNPJ Texto 30 Razaosocial Texto 50 Endereço Texto 80 Cidade Texto 20 Telefone Texto 14

Tabela Fornecedores

Campo Tipo Tamanho Cod_fornecedor Autonumeração Nome Texto 100 Telefone Texto 14 RazãoSocial Texto 30 CPF Texto 20 Cidade Texto 20

Tabela Produtos

Campo Tipo Tamanho Cod_produto Autonumeração Quantidade Número Descrição Texto 100 Tipodoproduto Texto 50

DELPHI


2. Salve o banco com o nome de controle_farmácia. 3. Crie a conexão via ODBC para esse banco de dados.

4. No Delphi, criar a conexão do banco de dados (Dica: utilizar o componente

Database).

5. Criar as telas de cadastro para: Produto; Cliente; Farmácia e Fornecedores.

6. Cadastrar no mínimo 03 registros.

7. Para a tela de produtos criar uma consulta por descrição do produto.

8. Para a tela de clientes criar uma consulta por nome, telefone e endereço.

9. Para a tela de fornecedores criar uma consulta por nome, telefone.

10. Salve o projeto com o nome de Farmácia.dpr.

Documents

Apostila Delphi 2010