Tópicos Avançados - MySQL

O MySQL 5, só é um SGBD útil se fizer uso de seus recursos!

Os novos recursos do SGBD são:

Triggers

Stored Procedures

Integridade Referencial (de verdade)

Transactions e etc...

Caso contrário, faz sentido usar apenas a versão 4.0

O MySQL tem uma característica única que é a possibilidade de escolha do tipo de tabela, cada uma com suas características para atender melhor, ou não, a determinadas tarefas. O MySQL também possui limitações relacionadas com o tipo de tabela utilizada no projeto.

Outro recurso acrescentado na ultima edição são os "Views". Possui também muitas capacidades que agregadas podem aumentar a capacidade, porém deve-se escolher o tipo de tabela utilizada.

Na documentação diz que uma Tablespace para tabelas do tipo InnoDB pode ter até 64TB.

O MySQL possui tabelas transacionais (innoDB) e não transacionais (MyISAM)... ok, o que é isto. Uma tabela transacional é uma tabela mais lenta e muito mais segura. Por exemplo em uma transação bancária se faltar eletricidade na transição de valores da conta x para a y... o MySQL (innoDB) após ser ativado novamente retornará o dinheiro para x ou y, não perderá tal quantia. Diferente de uma tabela do tipo MyISAM... Onde bye bye money.

Desenho 2D em Java - A classe Basic Stroke

A CLASSE BASICSTROKE.

A classe de BasicStroke define um jogo básico de atributos para os esboços dos gráficos primitivos, os mesmos tem um rendimento com ao de um objeto de Graphics2D, onde tem seu atributo do curso ajustado ao BasicStroke.
Os atributos definidos por BasicStroke descrevem a forma da marca feita por uma pena extraída ao longo do esboço de uma forma e das decorações aplicadas nas extremidades e juntam-na de segmentos do trajeto da forma, incluindo a largura, onde a largura da pena, é perpendicular a sua medida.
Classes Principais do BasicStroke são:

java.lang.Object
java.awt.Component
java.awt.Container
javax.swing.JComponent
javax.swing.JPanel

Image

A classe Image define uma imagem gráfica simples, genérica e bidimensional. A classe Graphics (usada pelo método paint) pode desenhar imagens com o método drawImage :
Image minhaImagem;
minhaImagem = createImage(50, 50);
g.drawImage(minhaImagem, 0, 0, this);
O método drawImage recebe quatro parâmetros - a imagem, as coordenadas x e y e a referência para ela mesma através da variável especial (this). Os formatos de gravura suportados pelos browsers, os mais comuns são os que possuem extensão GIF (Graphics Interchange Format) e o Joint Photographic Experts Group (JPEG). Essas imagens podem demorar um tempo para serem descarregadas.

import java.applet.*;
import java.awt.*;
public class draw_image extends Applet {
Image img;
public void init() {
img = getImage(getCodeBase(), "cow.gif");
}
public void paint(Graphics g) {
g.drawImage(img, 0, 0, this); } }
// Adiciona imagens
Formas, fontes e cores
Os recursos gráficos como formas, fontes e cores são utilizados a partir da classe java.awt, que proporciona o melhor acabamento visual da linguagem Java.
A maioria das operações básicas de desenho é composta de métodos definidos na classe Graphics. Não é necessário criar um objeto "Graphics" para desenhar algo, basta lembrar que um dos argumentos do método paint() é um objeto Graphics, como é demonstrado logo abaixo no exemplo que vai nos acompanhar por todo esse capítulo, demonstrando todo o processo de criação de um mapa da Flórida:

import java.awt.Graphics;
import java.awt.Polygon;
public class Map extends java.applet.Applet {
public void paint(Graphics screen) {
screen.drawString("Florida", 185, 75);
. . . . . . .} }

Esse applet usa o método drawString() do objeto screen para desenhar o string "Flórida" nas coordenadas 185,75. Assim como acontece com drawString(), todos os métodos de desenho possuem argumentos que indicam coordenadas x, y. Alguns exigem mais do que um conjunto de coordenadas, como uma linha que possui uma coordenada x, y para identificar seu ponto inicial e outra para seu ponto final. Lembrando que todos os valores em pixel são inteiros, não podendo ser usados números decimais para apresentar algo entre os valores inteiros.

Linhas

O método drawLine() é usado para desenhar uma linha entre dois pontos. O método recebe quatro argumentos: as coordenadas x e y do ponto inicial e as coordenadas x e y do ponto final. A espessura da linha fica fixa em 1 pixel. Será inserida a seguinte linha no código do Map:

screen.drawLine(185, 80, 222, 80);

Retângulos

Para desenhar um retângulo normal, use o método drawRect para os contornos e o método fillRect para as figuras preenchidas. Esses métodos recebem os seguintes argumentos - coordenadas x e y do canto superior esquerdo do retângulo, a largura e a altura do retângulo. Insira a seguinte instrução no applet:

screen.drawRect(2, 2, 345, 345);

Os retângulos cm cantos arredondados exigem os métodos drawRoundRect() e fillRoundRect() que recebem os quatro primeiros argumentos que os normais, com dois argumentos incluídos no final que definem a largura e a altura da área onde os cantos são arredondados, insira a seguinte instrução no applet:

screen.drawRoundRect(182, 61, 43, 24, 10, 8);

Polígonos

Podem ser desenhados com os métodos drawPolygon() e fillPolygon(), onde são necessárias as coordenadas x, y de cada ponto. São considerados como uma série de linhas unidas, onde ficam declarados o início e o fim de cada uma. Adicione as seguintes instruções ao método paint() do applet Map para ver os polígonos em ação :

int x[] = { 10, 234, 253, 261, 344, 336, 295, 259, 205, 211,
195, 191, 120, 94, 81, 12, 10 };
int y[] = { 12, 15, 25, 71, 209, 278, 310, 274, 188, 171, 174,
118, 56, 68, 49, 37, 12 };
int pts = x.length;
Polygon poly = new Polygon(x, y, pts);
screen.drawPolygon(poly);

Elipses

Essa forma segue a mesma novela das formas anteriores, possui os métodos drawOval() e fillOval() usados para desenhar círculos e elipses, possuem os quatro argumentos que definem as coordenadas x e y, a largura e a altura. Inclua as seguintes instruções para o applet:

screen.fillOval(235,140,15,15);
screen.fillOval(225,130,15,15);
screen.fillOval(245,130,15,15);
Exemplo - Formato de uma carinha através dos círculos preenchidos

Arcos

De todas as formas de desenho, os arcos são os mais complexos de se construir, possuindo seis argumentos - as coordenadas x e y, a largura e a altura da elipse, o ângulo em que se deve iniciar o arco e o número de graus percorrido pelo arco. Verifique a sintaxe para esses métodos através do código completo do programa Map.java :

import java.awt.Graphics;
import java.awt.Polygon;
public class Map extends java.applet.Applet {
public void paint(Graphics screen) {
screen.drawString("Florida", 185, 75);
screen.drawLine(185,80,222,80); //linha
screen.drawRect(2, 2, 345, 345);//retângulo
screen.drawRoundRect(182,61,43,24,10,8);//retangulo arredondado
int x[] = { 10, 234, 253, 261, 344, 336, 295, 259, 205, 211,
195, 191, 120, 94, 81, 12, 10 };
int y[] = { 12, 15, 25, 71, 209, 278, 310, 274, 188, 171, 174,
118, 56, 68, 49, 37, 12 };
int pts = x.length;
Polygon poly = new Polygon(x, y, pts);
screen.drawPolygon(poly);
screen.fillOval(235,140,15,15);//círculo preenchido
screen.fillOval(225,130,15,15);
screen.fillOval(245,130,15,15);
for (int ax = 50; ax < 150; ax += 10)
for (int ay = 120; ay < 320 ; ay += 10)
screen.drawArc(ax, ay, 10, 10, 0, -180);//Arco
}
}
Exemplo- Utilização das formas através de um mapa

Textos

Os objetos da classe java.awt.Font são usados para se utilizar o método drawString() com diferentes fontes. Os objetos Font representam o nome, o estilo e o tamanho em pontos de uma fonte. Outra classe, FontMetrics, fornece métodos para se determinar o tamanho dos que caracteres que estão sendo apresentados com uma fonte específica, o que pode ser usado para detalhes com formatação e centralização do texto.
Um objeto fonte é criado enviando-se três argumentos para o seu construtor :

Nome - pode ser específico como as fontes internas da linguagem Java: TimesRoman, Helvetica, Courier, Dialog e DialogInput;
Estilo - podem ser definidos como Font.PLAIN, Font.BOLD e Font.ITALIC;
O tamanho em pontos da fonte.
As fontes apresentam, portanto, a seguinte sintaxe :
Font f = new Font("Dialog", Font.ITALIC, 36);
Depois é só definir a fonte atual através do método setFont() que segue a sintaxe:
screen.setFont(f);
O applet SoLong apresenta um string no centro da janela Applet, usando FontMetrics para medir a largura do string com a fonte atual

import java.awt.Font;
import java.awt.Graphics;
import java.awt.FontMetrics;
public class SoLong extends java.applet.Applet {
public void paint(Graphics screen) {
Font f = new Font("Courier", Font.BOLD, 18);
FontMetrics fm = getFontMetrics(f);
screen.setFont(f);
String s = "So long, and thanks for all the fish.";
int x = (size().width - fm.stringWidth(s)) / 2;
int y = size().height / 2;
screen.drawString(s, x, y);
}
}

Utilização das fontes através do applet SoLong

O método size() pode não estar compatível com a versão 1.2, se durante a compilação ou execução do programa houver alguma rejeição referente a esse método, basta substituí-lo pelo método getSize().
Cores
As classes Color e ColorSpace do pacote java.awt pode ser usadas para tornar seus applets e aplicativos mais coloridos. Com essas classes, podem ser definidas a cor atual e ser usada nas operações de desenho, bem como a cor de fundo de um applet e de outras janelas. Também podem ser convertidas uma cor de um sistema de descrição de cores para outro.
Por definição, Java usa cores de acordo com um sistema de definição de cores chamado RGB ( essas letras provém das palavras Red, Green e Blue). Cada um dos três componentes pode ser representado por um inteiro de 0 a 255. Como será visto posteriormente no quadro de cores.
A cor atual do desenho é designada pelo método setColor() da classe Graphics. Uma forma de definir a cor é usando uma das cores padrão disponíveis, como as variáveis de classe na classe Color que apresentam os seguintes parâmetros :

black(0,0,0)
blue(0,0,255)
cyan(0,255,255)
darkGray(64,64,64)
orange(255,200,0)
pink(255,175,175)
gray(128,128,128)
red(255,0,0)
green(0,255,00)
white(255,255,255)
yellow(255,255,0)
lightGray(192,192,192)
Tabela -- Cores para applets

A instrução a seguir define a cor atual do objeto screen usando as variáveis de classe padrão:
screen.setColor(Color.orange);
Para criar um objeto cor com definições próprias, deve ser introduzido um código semelhante a esse:
Color novacor = new Color(255,204,102);
screen.setColor(novacor);

O método setBackground() define a cor de fundo de uma janela e o método setForeground() altera a cor de um componente de interface como um botão ou uma janela. Esses métodos recebem como argumento o objeto cor.
setBackground(Color.blue);

Ex:
import java.awt.*;
import java.awt.event.*;
public class janelaDesenho2 extends Frame {
private final int startPos = 50;
private int incremento = 15;
private int tamanho = 40;
class WindowHandler extends WindowAdapter {
public void windowClosing(WindowEvent we) {
dispose();
System.exit(0);
}
}
public janelaDesenho2() {
setTitle("Janela e desenho 2");
setSize(320,200);
addWindowListener(new WindowHandler());
}
public void paint(Graphics g) {
int x=startPos;
int y=startPos;
Dimension d = getSize();
int finalPos = Math.min(d.width, d.height)-tamanho;
Graphics2D g2 = (Graphics2D) g;
g2.setStroke(new
BasicStroke(10.0f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
g2.drawString("Desenhando...", 10, 40);
while (x < finalPos) {
g2.setColor(new Color((float)Math.random(),
(float)Math.random(),
(float)Math.random()));
g2.drawRect(x, y, tamanho, tamanho);
x += incremento;
y += incremento;
}
g2.setFont(g.getFont().deriveFont(Font.BOLD));
g2.setColor(Color.red);
g2.drawString("...pronto!", 100, 40);
}
public static void main(String[] args) {
janelaDesenho2 j = new janelaDesenho2();
j.setVisible(true);
}
}

import java.awt.*;
import java.awt.event.*;
public class janelaDesenho2 extends Frame {
private final int startPos = 50;
private int incremento = 15;
private int tamanho = 40;
class WindowHandler extends WindowAdapter {
public void windowClosing(WindowEvent we) {
dispose();
System.exit(0);
}
}
public janelaDesenho2() {
setTitle("Janela e desenho 2");
setSize(320,200);
addWindowListener(new WindowHandler());
}
public void paint(Graphics g) {
int x=startPos;
int y=startPos;

Dimension d = getSize();
int finalPos = Math.min(d.width, d.height)-tamanho;
Graphics2D g2 = (Graphics2D) g;

g2.setStroke(new
BasicStroke(10.0f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
g2.drawString("Desenhando...", 10, 40);
while (x < finalPos) {
g2.setColor(new Color((float)Math.random(),
(float)Math.random(),
(float)Math.random()));
g2.drawRect(x, y, tamanho, tamanho);
x += incremento;
y += incremento;
}
g2.setFont(g.getFont().deriveFont(Font.BOLD));
g2.setColor(Color.red);
g2.drawString("...pronto!", 100, 40);
}
public static void main(String[] args) {
janelaDesenho2 j = new janelaDesenho2();
j.setVisible(true);
}
}

PROJETO DE BANCO DE DADOS - APRENDENDO A 4º FORMA NORMAL (4FN)

ALGORITMOS PARA PROJETO DE BANCO DE DADOS RELACIONAL E DEMAIS DEPENDÊNCIAS

Um problema ocorre quando são permitidos valores “null” para atributos que serão usados em junção natural de tabelas, elas simplesmente desaparecerão no resultado da visão.

Sempre que um BD for projetado com ligações de chaves estrangeiras, deve-se tomar cuidado com valores “null”. O que ocasiona perda inesperada de informações em consultas que envolvam junções.

Deve-se considerar também a possibilidade de usar “null” em atributos que são usados em funções pré-definidas como: soma e média.

A Quarta Forma Normal é definida pelo conceito de dependência multivalorada. As dependência multivaloradas (DMV) são conseqüências da primeira forma normal (atomicidade).

A seguinte tabela não está na 4 forma normal. Nela temos alguns empregados que participam de alguns projetos e possuem dependentes em cada projeto. A chave é definida por todas as colunas.

EMP

ENOME	PNOME	DNOME
Smith	X	John
Smith	Y	Anna
Smith	X	Anna
Smith	Y	John
Brown	W	Jim
Brown	X	Jim
Brown	Y	Jim
Brown	Z	Jim
Brown	W	Joan
Brown	X	Joan
Brown	Y	Joan
Brown	Z	Joan
Brown	W	Bob
Brown	X	Bob
Brown	Y	Bob
Brown	Z	Bob

Há 16 tuplas na tabela acima. Consideremos que Brown comece a trabalhar em um novo projeto (P) deveriamos incluir três tuplas!!! Uma para cada dependente. Se esquecremos de incluir alguma, violaríamos a DMV e o projeto ficaria inconsistente.

Agora raciocinem comigo.

Se os dependentes estão para os empregados, e os projetos também estão para os empregados. Logo poderíamos quebrar esta tabela em duas!

EMP_Projetos

ENOME	PNOME
Smith	X
Smith	Y
Brown	W
Brown	X
Brown	Y
Brown	Z

EMP_ Dependentes

ENOME	DNOME
Smith	Anna
Smith	John
Brown	Jim
Brown	Joan
Brown	Bob

Vejam bem, na primeira relação eram 16 linhas na tabela! Agora com a 4FN são apenas 11. Obtivemos um ganho aí.

Agora de volta a questão...

E se Brown participasse de um novo projeto, o projeto P?
Agora que a tabela está normalizada basta acrescentarmos uma tupla na tabela EMP_Projetos e voilá! Não precisamos nos preocupar com os dependentes que já estão cadastrados ;)

Por enquanto fico por aqui! O capítulo em questão do Navathe ainda aborda sobre algoritmos de preservação de dependência de uma decomposição e propriedades de junção sem perda. Fala também da 5FN (dependências de Junção) além de dependências de inclusão, dependências template e forma normal domínio-chave.

Todas estas, para mestres em BD explicarem =]

TIPOS NUMÉRICOS COM PONTOS FLUTUANTES

O tipo de dado é uma das coisas que devem ser definidas na hora de projetar um Banco de Dados. No MySQL, os tipos de dados que temos para representar os números são:

binary, bit, decimal, double, float, int, mediumint, real e smallint.

Esta dica é bem rápida. Quando se declara um tipo de campo como numérico, em alguns casos temos a opção de definir dois algarismos. Geralmente isso acontece nos seguintes tipos:

Float, double e decimal.

Nestes casos, o algarismo mais a esquerda deve ser declarado como sendo maior ou igual ao da direita (depois do ponto).

Logo não se pode declarar:

CREATE TABLE teste (Preço DECIMAL (2,5));

Outra coisa que deve-se estar atento é que, o número da direita representa o número de algarismos de precisão decimal, que o campo conterá. A seguir apresento mais uma definição:

CREATE TABLE teste (Preço FLOAT (5,5));

Na linha acima eu estou declarando valores para meu campo, numa faixa de -0,99999 até 0,99999.

O que se conclui é que a precisão (número após a vírgula) deve estar reservada e levada em consideração quando se declarar o número da esquerda. Se não entendeu aqui vai outro exemplo:

CREATE TABLE teste (Preço DOUBLE (7, 5));

O que disse na linha de cima foi:

Crie uma tabela com o nome teste, onde ela apresenta o campo preço como tendo o tipo “double”, em que nela poderá ser declarada 7 algarismos como valor, sendo cinco deles reservado para números decimais.

Concluindo, se eu quero que meu campo armazena uma faixa de valores de -999,99 até 999,99

Eu declaro 5 algarismos, reservando dois para números fracionários. O exemplo fica assim:

CREATE TABLE teste (Preço DECIMAL (5,2));

Espero que tenham gostado.

Compilando no Braço

Você já parou para pensar em quantas linguagens de programação são interpretadas? Senão pense rápido.

Para fazer esta dica de Lord ou código fonte (como queiram chamar) você precisa de um JDK ou SDK instalado. (tem diferença de um pro outro, pesquisa no google que acha)

O JDK inclui tudo o que você precisa para começar a rodar seus códigos java. (a diferença de JDK pra JRE e JVM você também acha no google)

Você sabia que o Java 1.5 foi chamado de Tiger?

Uma vez um professor meu de Estrutura de Dados disse que programador bom tem que aprender a criar código em bloco de notas, e programadores antigos também gostam disso. Daí eu quis aprender como o java funciona desta maneira. Daí saiu este toque para vocês.

Uma coisa que você leva pro resto da vida, é que o Java trabalha com Class-path. Este é um caminho que o Java faz toda a vez que você pede um recurso, ou seja, importa uma classe, um pacote, foto, qualquer coisa. Muita gente nem sabe o que é. Os que sabem não tem noção que existem dois classpath. Um é do Java e outor do seu projeto (se você vai criar um programa profissional pra vender...).

Pra gente compilar no braço temos que criar uma variável de sistema no ambiente do windows que indique o classpath do Java. Bora lá:

Passo 1: Dê um clique com botão direito em cima do ícone meu computador, na área de trabalho, no menu que aparece clique na opção "propriedades".

Passo 2: Após termos clicado na opção "propriedade", a janela propriedades do sistema será mostrada, clique na guia "Avançado".

Passo 3: Após termos clicado na guia "Avançado" a janela propriedades do sistema ficara igual a apresentada a seguir, clique no botão "Variáveis de ambiente...".

Passo 4: Após termos clicado no botão "Variáveis de ambiente..." da janela propriedades do sistema a janela variáveis de ambiente, será mostrada. Nesta tela temos dois lugares para configurar as variáveis de ambiente, podemos ainda editar ou excluir uma variável de sistema já existente. Clique no botão superior "Nova...", para configurarmos as variáveis de ambiente para o usuário corrente, ou seja, o usuário que está logado no momento.

Observação: Neste tutorial iremos configurar as variáveis de ambiente para o usuário corrente, mas o processo para configura as variáveis do sistema e o mesmo.

Passo 5: Após temos clicado no botão "Nova...", na janela variáveis de ambiente a janela "Editar variável do usuário" será exibida. A partir deste ponto devemos definir as seguintes variáveis de ambiente: JAVA_HOME, CLASSPATH e PATH. As próximas figuras demonstram como configurar as variáveis de ambiente. Após termos digitado os valores conforme as figuras, clique no botão "Ok", repita o processo para as três variáveis de ambiente.

JAVA_HOME: Esta variável de ambiente apontará para o diretório onde o J2SDK foi instalado, no caso "C:\jdk1.5.0". Em um outro artigo iremos nos aprofundar nesta variável, no momento apenas configure igual à figura abaixo...

Se você está gostando e quer continuar lendo este artigo na íntegra, clique aqui.

Obs.: JAVA é compilada e interpretada, por isso pode ser chamada de compilação sim! Peço desculpas e Agradeço meu amigo Manoel pelo toque.

Quando o compilador java é invocado, é criado um arquivo *.class

O compilador transforma o código-fonte em algo um pouco mais difícil de ser lido e entendido. O código que temos no class é chamado de bytecodes, isto é, um código intermediário que somente a máquina virtual Java compreende.

Em seguida os bytecodes são INTERPRETADOS pela JVM e o programa é executado.

Uma curiosidade é que, se qualquer alteração for feita no bytecode, por segurança o Java, inutiliza o arquivo. Ainda que a alteração seja inteligível. Esta como disse acima é uma restrição de segurança dos bytecodes.