Arquivo de setembro, 2014

O sistema operacional livre mais famoso e o favorito dos desenvolvedores está disponível para desktops, servidores, tabletssmartphones e com ele uma gama de novas possibilidades para se desenvolver aplicativos poderosos que cruzam os mais diferentes dispositivos.

Munidos dos recursos de modelos do Ubuntu, divididos entre Apps, no qual o desenvolvedor pode escrever uma variedade de aplicações utilizando QML, HTML5 e Cordova e dos Scopes utilizando visões dedicadas que organizam, buscam e mostram uma variedades de tipos e conteúdos na internet ou no dispositivo local, fazem do Ubuntu SDK um conjunto completo de ferramentas de alto nível para criar aplicações elegantes e funcionais que também proporcionam ao desenvolvedor força extra para manipular processos mais complicados, utilizando o poder do C++ que é a linguagem de programação escolhida para fechar com chave de ouro o Kit de desenvolvimento do Ubuntu

Ubuntu Phone: http://www.ubuntu.com/phone

E para aqueles que adoram provar que o Linux é sempre melhor que o Windows, podem se deliciar com as possibilidades da IDE gráfica do QTCreator que faz parte do Kit de desenvolvimento do Ubuntu e com seus recursos modernos tanto de design como de edição, e se adicionada a programação C++ visual para Linux com Qt (Signals e Slots) constata-se que é muito mais eficaz e rápida do que a do Windows (Message Map) pois não utiliza a arquitetura de mensagens de loops, fazendo o Visual Studio da Microsoft parecer o editor de textos Microsoft Word. E se compararmos as funcionalidades e produtividade da IDE visual para C++ do QT com a IDE visual para C++ do MFC (que por sinal é quase a mesma do .NET) você poderá ver que há vários recursos sobre layouts e manipulação de componentes que o Visual Studio não possui, além da diferença de código, o MFC gera um código automático muito maior para a mesma aplicação, contudo ainda é possível portar seus aplicativos MFC para a plataforma Linux.

Qt-Project: http://qt-project.org/

Sobre MFC e Linux: https://www.novell.com/coolsolutions/feature/11244.html

Instalando o Ubuntu SDK

O Ubuntu SDK permite que você desenvolva software para a ultima versão de sua plataforma, para isto precisamos garantir que os pacotes do seu sistema operacional estejam atualizados.

sudo apt-get update && sudo apt-get dist-upgrade
sudo add-apt-repository ppa:ubuntu-sdk-team/ppa
sudo apt-get update && sudo apt-get install ubuntu-sdk

Se estiver utilizando o Ubuntu em uma maquina virtual, a atualização de pacotes podem requerer que você reinstale os adicionais para convidados para obter a resolução widescreen da tela, veja como efetuar este procedimento em nosso post de como instalar o Ubuntu em uma maquina virtual. Outras informações sobre o Ubuntu SDK:

Ubuntu Developer: http://developer.ubuntu.com/

Configurando o Ubuntu SDK e Criando uma Aplicação

1- Após a instalação abra o Ubuntu SDK na barra de ferramentas ou abra o QTCreator. Qualquer uma das opções mostrará a janela de boas vindas do Ubuntu SDK, clique em Next:

Bem-Vindo

Bem-Vindo

2 – Na janela Build Targets, você pode criar a plataforma em que deseja compilar seus aplicativos e também escolher a versão do framework para desenvolvimento, elas são AMD64, ARMhf e i386, crie um novo kit AMD64 para garantir que todos os pacotes sejam baixados e aguarde, este procedimento pode levar algum tempo:

Criando Kit da plataforma (pode demorar)

Criando Kit da plataforma (pode demorar)

3 – Após criar o kit clique em Next para pular a criação de um emulador de dispositivos já que vamos utilizar um projeto desktop e clique em Finish para abrir o QtCreator:

Ubuntu SDK - QTCreator

Ubuntu SDK – QTCreator

4 – Com a IDE aberta clique no menu File e escolha novo projeto, na janela de modelos de projetos, em projetos escolha Applications e selecione a opção Qt Widget Application e clique em Choose:

Tipos de Projetos

Tipos de Projetos

5 – Na janela de propriedades do projeto em Name escolha MinhaApp, em Create in escolha um diretório de sua preferencia e clique em Next:

Propriedades do Projeto

Propriedades do Projeto

6 – Na janela Kit Selection escolha Desktop e clique em Next:

Kit de compilação

Kit de compilação

7 – Na janela Class Information podemos mudar os nomes de arquivos para a classe do projeto, neste primeiro momento apenas clique em Next:

Informações da Classe

Informações da Classe

8 – Na janela Project Management podemos escolher um controlador de versões para o projeto, por enquanto clique em Finish:

Gerenciamento do Projeto

Gerenciamento do Projeto

9 – Pronto você já pode ver o código fonte C++ na sua IDE, na janela Projects expanda o node Form e dê um duplo clique em mainwindow.ui para ir para o modo de design do formulário. Utilize a paleta de widgets para arrastar os componentes para o Form, arraste 4 Labels, 3 LineEdits e um PushButton, utilize a barra de ferramentas para alinhar os componentes no formulário e altere suas propriedades na janela de propriedades no canto inferior direito da tela:

Form - Design

Form – Design

10 – Após terminar o design do formulário, para criar o evento de clique do botão, selecione o componente PushButton, clique com botão direito do mouse e escolha a opção Go to Slot e na janela seguinte escolha o método Clicked() e clique OK:

Slot - Evento de Clique

Slot – Evento de Clique

11 – Você foi direcionado para o código fonte no método de clique do botão, preencha o método com o código encontrado logo abaixo e clique em RUN na barra de ferramentas do lado inferior esquerdo da IDE (seta verde):

Código Fonte - C++

Código Fonte – C++

12 – Pronto, você já criou seu primeiro programa utilizando os recursos básicos dos Widgets Qt utilizando o Kit de desenvolvimento do Ubuntu:

Ubuntu SDK - C++ - Programa

Ubuntu SDK – C++ – Programa

Agora você pode seguir os outros posts sobre como desenvolver aplicativos para o sistema operacional Ubuntu neste site.

Exemplo:

Neste exemplo criamos um aplicativo básico C++ utilizando os Widgets Qt.

C++

mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);
}

MainWindow::~MainWindow()
{
    delete ui;
}

void MainWindow::on_pushButton_clicked()
{
    ui->lineEdit->setText("Desenvolvimento Aberto");
    ui->lineEdit_2->setText("Ubuntu - SDK - C++");
    ui->lineEdit_3->setText("QtCreator 3.1.1 - Qt 5.2.1");
}
Anúncios

Database – Sequence – Oracle – Python

Publicado: 29 de setembro de 2014 em Python

Uma Sequence é um objeto de banco de dados encontrado no bancos de dados Oracle, que permite a geração automática de valores, tais como números de identificação. Sequências são ideais para a tarefa de gerar valores de chaves únicas. Os aplicativos podem usar sequências para evitar possíveis problemas de simultaneidade e de desempenho resultantes de valores de coluna. A vantagem que tem sobre as  sequências de números criados fora do banco de dados é que o servidor de banco de dados mantém o registro dos números gerados e nenhum tipo de acidente no banco de dados causará números duplicados.

Oracle: Sequence

Sequence - Oracle - Python

Sequence – Oracle – Python

Algo extremamente útil sobre Sequence

Utilizar um objeto ou uma propriedade auto incremento é o método correto para criar IDs automáticos no banco de dados, nunca utilize uma Trigger para executar este procedimento, pois deste modo você esta reduzindo sensivelmente a performance do banco de dados, visto que você precisa de acessos e objetos extras para executar a mesma função.

Para valores de Sequence que são utilizados fora do banco de dados, por exemplo, números de sequência usados ​​para identificadores externos (números de cheques bancários ou outros), se o banco de dados é recuperado para um ponto no tempo antes de uma falha, então isso poderia causar a geração de valores duplicados para algumas sequências. Para evitar possíveis valores duplicados, bancos de dados que usam valores de sequência fora do banco de dados não deve ser recuperado para um ponto anterior no tempo.

Exemplo:

Neste exemplo utilizamos uma Sequence para os bancos de dados Oracle para criar identificadores automáticos para a coluna chave de uma tabela.

SQL

Oracle

-- Cria sequencia
CREATE SEQUENCE Sequencia_seq
 START WITH     1
 INCREMENT BY   1
 NOCACHE
 NOCYCLE;

-- Cria tabela
CREATE TABLE SEQUENCIA (
   Identificador   NUMBER(10),
   Nome            VARCHAR(30),
   Sobrenome       VARCHAR(70),
   Cargo           VARCHAR(30),
   Salario         Decimal(9,2));

 -- Testa sequencia
insert into SEQUENCIA VALUES (Sequencia_seq.NEXTVAL ,'Teste','Teste Sobrenome','Programador',2234.56);

-- verifica resultado
SELECT * FROM SEQUENCIA

Python

#!/usr/bin/env python
# -*- coding: latin-1 -*-
# Desenvolvimento Aberto
# Sequence.py
 
# importa modulos
import wx
import wx.grid
import cx_Oracle
 
# Cria classe generica de uma WX.Grid
# A classe abaixo faz parte da documentação WXPython oficial
# Este trecho de código é util para manipular a grade
 
class GenericTable(wx.grid.PyGridTableBase):
    def __init__(self, data, rowLabels=None, colLabels=None):
        wx.grid.PyGridTableBase.__init__(self)
        self.data = data
        self.rowLabels = rowLabels
        self.colLabels = colLabels
 
    def GetNumberRows(self):
        return len(self.data)
 
    def GetNumberCols(self):
        return len(self.data[0])
 
    def GetColLabelValue(self, col):
        if self.colLabels:
            return self.colLabels[col]
 
    def GetRowLabelValue(self, row):
        if self.rowLabels:
            return self.rowLabels[row]
 
    def IsEmptyCell(self, row, col):
        return False
 
    def GetValue(self, row, col):
        return self.data[row][col]
 
    def SetValue(self, row, col, value):
        pass    
 
# Inicializa Grade
dados = []
colLabels  = []
rowLabels = []
for linha in range(1, 150):
    rowLabels.append(str(linha))

# Cria conexão
def conectarORA():
    sconexao = "user/pass@localhost/XE"
    try:
       con = cx_Oracle.connect(sconexao)
    except ValueError:
       tkMessageBox.showinfo(title="Menssagem", message="Erro de Conexão", parent=janela)
    return con
 
# Executa e retorna SQL
def retornaTabelaORA(sql, con):
     cursor = con.cursor()
     cursor.execute(sql)
     return cursor
 
def retornaDados():
    # Cria conexão
    con = conectarORA()
    # Envia dados a grid
 
    sql = "Select * from SEQUENCIA WHERE IDENTIFICADOR = (SELECT MAX(IDENTIFICADOR) FROM SEQUENCIA)"
    # retorna set de dados
    tabela = retornaTabelaORA(sql, con)
 
    # Retorna metadados da tabela
    for i in range(0, len(tabela.description)):
        colLabels.append(tabela.description[i][0])
 
    # Executa um fecth em todos os registros
    resultado = tabela.fetchall()
 
    # Popula dados
    for conteudo in resultado:
        dados.append(conteudo)
 
# Cria classe da grid
class SimpleGrid(wx.grid.Grid):
    def __init__(self, parent):
        wx.grid.Grid.__init__(self, parent, -1, pos=(5,50), size=(850,350))    
 
# Cria formulario
class TestFrame(wx.Frame):
    def __init__(self, parent):
        wx.Frame.__init__(self, parent, -1, "Desenvolvimento Aberto - SEQUENCE - ORACLE - Python", size=(900, 450))
        panel        = wx.Panel(self, wx.ID_ANY)
        label        = wx.StaticText(panel, -1, label='Oracle Database - Sequence - Clique no botão para inserir um numero sequencial do Oracle', pos=(5,20))
        botao        =   wx.Button(panel, label="Inserir", pos=(760,10))
        botao.Bind(wx.EVT_BUTTON, self.botaoInserir)
        self.grid         = SimpleGrid(panel)
        
    #Insere dados e dispara trigger
    def botaoInserir(self,event):
        # Conecta e cria um cursor
        con = conectarORA()
        cursor = con.cursor()
        # Insere clausula SQL
        sql = "insert into SEQUENCIA VALUES (Sequencia_seq.NEXTVAL ,\'Teste\',\'Teste Sobrenome\',\'Programador\',2234.56)"
        # Executa e comita a transação
        cursor.execute(sql)
        con.commit()        
        # Limpa grade
        self.grid.ClearGrid()
        # Atualiza grade
        self.grid.ForceRefresh()
        # Retorna set de dados
        retornaDados()        
        # Insere set de dados contidos em um tuplas
        tableBase = GenericTable(dados, rowLabels, colLabels)
        self.grid.SetTable(tableBase)
        
 
# Inicializa a aplicação
app = wx.App()
frame = TestFrame(None)
frame.Show(True)
app.MainLoop()

Quickly é um framework que contem as funcionalidades de uma IDE RAD para a criação de software para Ubuntu utilizando Python, PyGTK, Glade Interface Designer e Desktop Couch. Após sua aplicação já desenvolvida, você pode facilmente publica-la usando Bzr e Launchpad. Dada a riqueza e variedade da plataforma, Quickly torna a programação em Linux fácil e divertida.

Quickly foi projetado para acelerar o início de novos projetos com o uso de modelos, não só para os programas, mas para qualquer tipo de projeto. Esses modelos são utilizados para automatizar a configuração de projeto e de manutenção, partindo do principio que delegar utilizando modelos e não uma biblioteca específica permite que projetos criados usando Quickly não exijam dependências de qualquer biblioteca em particular ou em tempo de execução, além do próprio Quickly.

Quickly Framwork:

Instalando o Quickly

O Quickly é utilizado através do terminal do Linux e é composto de diversos outros softwares que permitem que o Quickly funcione como uma IDE para desenvolvimento rápido de aplicações, deste modo é possível desenvolver aplicativos utilizando o conceito visual de “Drag and Drop” como o conceito de IDEs famosas como Design First… Code Later do Visual Studio ou Design Free do Netbeans para Java. Para instalar digite a instrução a seguir no terminal ou utilize a Central de Programas do Ubuntu:

sudo apt-get install quickly quickly-ubuntu-template
Central de Programas - Quickly

Central de Programas – Quickly

 

 Utilizando o Quickly

1 – O Quickly é composto de alguns comandos básicos como Create, edit, design, run e tutorial. Para criar seu primeiro projeto de um aplicativo Ubuntu, abra o terminal do Linux e digite o comando abaixo, um modelo de aplicação Linux Ubuntu visual será gerado automaticamente utilizando alguns Widgets básicos de uma aplicação GTK, como um container, menu, barra de status, label e um image:

quickly create ubuntu-application DevAHelloWorld
Projeto e App - Quickly

Projeto e App – Quickly

2 – Feche a janela da aplicação modelo. Você pode abrir o explorador de arquivos do Linux e verificar que o Quickly criou um Template de um aplicativo completo para o Python, navegue e analise sua pasta pessoal no qual contem um pasta com o nome do projeto que criamos:

Template App - Python

Template App – Python

3 – De volta ao terminal, agora vamos entrar na pasta do nosso projeto e executar o comando para abrir a IDE visual Glade e modificar nossa aplicação:

cd devahelloworld
quickly design
Terminal - Pasta Projeto

Terminal – Pasta Projeto

4 – Já no Glade constatamos que o programa inicial contem os componentes do GTK+ contidos dentro de um componente VBOX, faça uma breve analise do visual do Glade e constate que do lado esquerdo temos os Widgets Gtk, na janela do meio temos o formulário do nosso programa, na janela da direita temos o explorador do projeto e logo abaixo a janela de propriedades dos Widgets selecionados,

Template - Quickly - Python

Template – Quickly – Python

5 – No explorador do projeto apague o componente Image e o Statusbar e mude a propriedade do Label. O conceito de Widgets do GTK+ é baseado em containers então precisamos preencher as colunas vazias do VBox com novos Widgets de nossa escolha.

IDE Glade - Apagando Widgets default

IDE Glade – Apagando Widgets default

6 –  Arraste um objeto Grid para a coluna do meio do VBOX e mude sua propriedade para 2 colunas e 3 linhas e arraste um componente GTKButton na ultima coluna do VBox, mude suas propriedades a sua preferencia. Dentro das colunas do componente Grid adicione 3 componentes Labels e 3 componentes Entrys e mude as propriedades e os alinhe como preferir, usando a janela de propriedades de cada componente:

Widgets - Grid, Labels e Entrys

Widgets – Grid, Labels e Entrys

7 – Após terminar seu design, clique no botão, na janela de propriedades e clique na aba Sinais para criar um evento de clique para o botão. Escolha a opção Clicked e o manipulador on_button1_clicked, veja a figura abaixo para referencia:

Evento de Clique do botão

Evento de Clique do botão

8 – Após terminar todo o seu design, salve e volte para o terminal, digite a instrução abaixo para acessar o código fonte Python:

quickly edit
GEdit - Projeto Python - Quickly

GEdit – código fonte- Projeto Python – Quickly

9 – Altere o código gerado automaticamente com a linha marcada no código fonte logo abaixo e no terminal utilize o comando a seguir para rodar seu projeto:

quickly run
Python - PyGtk - Programa

Python – PyGtk – Programa

Pronto! Você já criou sua primeira aplicação Python para Ubuntu utilizando o framework Quickly. Agora você precisa definir a licença do seu projeto e pode disponibiliza-lo no site Launchpad da Canonical. Você pode facilmente executar estes procedimentos, para fazer isto e para se aprimorar sobre como criar aplicações de um modo rápido no Ubuntu, consulte o tutorial utilizando a seguinte linha de comando:

quickly tutorial

Para saber mais sobre como programar para o sistema operacional Linux Ubuntu:

Ubuntu Developers: http://developer.ubuntu.com/

Python

DevahelloworldWindow.py

# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
### BEGIN LICENSE
# This file is in the public domain
### END LICENSE

from locale import gettext as _

from gi.repository import Gtk # pylint: disable=E0611
import logging
logger = logging.getLogger('devahelloworld')

from devahelloworld_lib import Window
from devahelloworld.AboutDevahelloworldDialog import AboutDevahelloworldDialog
from devahelloworld.PreferencesDevahelloworldDialog import PreferencesDevahelloworldDialog

# See devahelloworld_lib.Window.py for more details about how this class works
class DevahelloworldWindow(Window):
    __gtype_name__ = "DevahelloworldWindow"
    
    def finish_initializing(self, builder): # pylint: disable=E1002
        """Set up the main window"""
        super(DevahelloworldWindow, self).finish_initializing(builder)

        self.AboutDialog = AboutDevahelloworldDialog
        self.PreferencesDialog = PreferencesDevahelloworldDialog

        # Code for other initialization actions should be added here.
         
        # Desenvolvimento Aberto - Declara Widget Glade
        self.button1 = self.builder.get_object("button1")

    def on_button1_clicked(self, widget):
        Gtk.main_quit()

 

 

Uma Sequence é um objeto de banco de dados encontrado nos bancos de dados Oracle e IBM DB2, que permite a geração automática de valores, tais como números de identificação. Sequências são ideais para a tarefa de gerar valores de chaves únicas. Os aplicativos podem usar sequências para evitar possíveis problemas de simultaneidade e de desempenho resultantes de valores de coluna. A vantagem que tem sobre as  sequências de números criados fora do banco de dados é que o servidor de banco de dados mantém o registro dos números gerados e nenhum tipo de acidente no banco de dados causará números duplicados.

Sequence & Identity - C++

Sequence & Identity – C++

Identity é encontrado no banco de dados Micosoft SQL Server e é muito similar ao Sequence e possui o mesmo objetivo que é de criar números sequenciais, porem não é um objeto do banco de dados e sim uma propriedade de uma coluna pertencente a uma tabela. Quando você insere um valor em uma tabela que possui uma propriedade Identity você deve excluir o campo referente a esta coluna da clausula SQL, sendo assim o MSSQL Server é o único banco de dados que permite que a quantidade de colunas na linha Values da instrução Insert seja diferente da quantidade de colunas na tabela do banco de dados.

sequence-3-sql-server

MSSQL – Identity – Propriedades

Para saber mais detalhes sobre os recursos dos objetos Sequences ou da propriedade Identity recomendamos que você utilize os links oficiais de cada banco de dados:

Oracle: Sequence
IBM DB2: Sequence
MSSQL Server: Identity

Algo extremamente útil sobre Sequence ou Identity

Utilizar um objeto ou uma propriedade auto incremento é o método correto para criar IDs automáticos no banco de dados, nunca utilize uma Trigger para executar este procedimento, pois deste modo você esta reduzindo sensivelmente a performance do banco de dados, visto que você precisa de acessos e objetos extras para executar a mesma função.

Para valores de Sequence ou Identity que são utilizados fora do banco de dados, por exemplo, números de sequência usados ​​para identificadores externos (números de cheques bancários ou outros), se o banco de dados é recuperado para um ponto no tempo antes de uma falha, então isso poderia causar a geração de valores duplicados para algumas sequências. Para evitar possíveis valores duplicados, bancos de dados que usam valores de sequência fora do banco de dados não deve ser recuperado para um ponto anterior no tempo.

Visual Studio

Para efetuar as conexões com os diferentes bancos de dados você precisa primeiro configurar os drivers ODBC necessários no sistema operacional, depois você pode criar um design com 3 componentes RadioButton, um componente Button e um componente CListControl,  você encontra um walkthrough de como configurar os drivers ODBC na categoria SQL e C++ deste site, use a figura abaixo para referencia do design:

Visual Studio - Design - cpp

Visual Studio – Design – MFC Dialog Based

 

Exemplo:

Neste exemplo utilizamos uma Sequence para os bancos de dados Oracle e IBM DB2 e uma propriedade Identity para o banco de dados MSSQL para criar identificadores automáticos para a coluna chave de uma tabela.

SQL

Oracle

-- Cria sequencia
CREATE SEQUENCE Sequencia_seq
 START WITH     1
 INCREMENT BY   1
 NOCACHE
 NOCYCLE;

-- Cria tabela
CREATE TABLE SEQUENCIA (
   Identificador   NUMBER(10),
   Nome            VARCHAR(30),
   Sobrenome       VARCHAR(70),
   Cargo           VARCHAR(30),
   Salario         Decimal(9,2));

 -- Testa sequencia
insert into SEQUENCIA VALUES (Sequencia_seq.NEXTVAL ,'Teste','Teste Sobrenome','Programador',2234.56);

-- verifica resultado
SELECT * FROM SEQUENCIA

IBM DB2

-- Cria Sequencia
CREATE SEQUENCE Sequencia_seq
 START WITH     1
 INCREMENT BY   1
 NOCACHE
 NOCYCLE;

-- Cria tabela
CREATE TABLE SEQUENCIA (
   Identificador   INTEGER,
   Nome            VARCHAR(30),
   Sobrenome       VARCHAR(70),
   Cargo           VARCHAR(30),
   Salario         Decimal(9,2));

 -- Testa Sequencia
insert into SEQUENCIA VALUES (Sequencia_seq.NEXTVAL ,'Teste','Teste Sobrenome','Programador',2234.56);

-- Verifica resultado
Select * from SEQUENCIA;

MSSQL

-- Cria tabela / Identity
CREATE TABLE SEQUENCIA(
	Identificador int IDENTITY(1,1) NOT NULL,
	Nome          nvarchar(30) NULL,
	Sobrenome     nvarchar(70) NULL,
	Cargo         nvarchar(30) NULL,
	Salario       decimal(9, 2) NULL);

-- Testa identação
insert into SEQUENCIA VALUES ('Teste','Teste Sobrenome','Programador',2234.56);

-- Verifica tabela
select * from SEQUENCIA;

C++

Classe – Definição – arquivo .h

// Classe gerada automaticamente
// AcessocppDlg.h : header file
//

#pragma once

// Inclui classe de banco de dados MFC
#include "afxdb.h"
#include "afxcmn.h"
#include "afxwin.h"


class CAcessocppDlg : public CDialogEx
{

public:
	CAcessocppDlg(CWnd* pParent = NULL);	// standard constructor

	enum { IDD = IDD_ACESSOCPP_DIALOG };

	protected:
	virtual void DoDataExchange(CDataExchange* pDX);	// DDX/DDV support
	
protected:
	HICON m_hIcon;

	virtual BOOL OnInitDialog();
	afx_msg void OnSysCommand(UINT nID, LPARAM lParam);
	afx_msg void OnPaint();
	afx_msg HCURSOR OnQueryDragIcon();
	DECLARE_MESSAGE_MAP()
public:
	
	// Cria métodos e objetos da classe
	CDatabase db;
	CString bancodedados;
	void conectarDB(CString dns, CString usuario, CString senha);
		
	afx_msg void OnBnHotItemChangeRadio1(NMHDR *pNMHDR, LRESULT *pResult);
	afx_msg void OnBnHotItemChangeRadio2(NMHDR *pNMHDR, LRESULT *pResult);
	afx_msg void OnBnHotItemChangeRadio3(NMHDR *pNMHDR, LRESULT *pResult);
	afx_msg void OnBnClickedButton1();
	
	CListCtrl m_tabela;
	
};

Classe – Implementação – arquivo .cpp

// Código gerado automaticamente
// AcessocppDlg.cpp : implementation file
//

#include "stdafx.h"
#include "Acessocpp.h"
#include "AcessocppDlg.h"
#include "afxdialogex.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

class CAboutDlg : public CDialogEx
{
public:
	CAboutDlg();

	enum { IDD = IDD_ABOUTBOX };

	protected:
	virtual void DoDataExchange(CDataExchange* pDX);   

protected:
	DECLARE_MESSAGE_MAP()
};

CAboutDlg::CAboutDlg() : CDialogEx(CAboutDlg::IDD)
{
}

void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
}

BEGIN_MESSAGE_MAP(CAboutDlg, CDialogEx)
END_MESSAGE_MAP()


CAcessocppDlg::CAcessocppDlg(CWnd* pParent /*=NULL*/)
	: CDialogEx(CAcessocppDlg::IDD, pParent)
{
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

void CAcessocppDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_LIST2, m_tabela);
}

BEGIN_MESSAGE_MAP(CAcessocppDlg, CDialogEx)
	ON_WM_SYSCOMMAND()
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	ON_NOTIFY(BCN_HOTITEMCHANGE, IDC_RADIO1, &CAcessocppDlg::OnBnHotItemChangeRadio1)
	ON_NOTIFY(BCN_HOTITEMCHANGE, IDC_RADIO2, &CAcessocppDlg::OnBnHotItemChangeRadio2)
	ON_NOTIFY(BCN_HOTITEMCHANGE, IDC_RADIO3, &CAcessocppDlg::OnBnHotItemChangeRadio3)
	ON_BN_CLICKED(IDC_BUTTON1, &CAcessocppDlg::OnBnClickedButton1)
END_MESSAGE_MAP()


BOOL CAcessocppDlg::OnInitDialog()
{
	CDialogEx::OnInitDialog();

	ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
	ASSERT(IDM_ABOUTBOX < 0xF000);

	CMenu* pSysMenu = GetSystemMenu(FALSE);
	if (pSysMenu != NULL)
	{
		BOOL bNameValid;
		CString strAboutMenu;
		bNameValid = strAboutMenu.LoadString(IDS_ABOUTBOX);
		ASSERT(bNameValid);
		if (!strAboutMenu.IsEmpty())
		{
			pSysMenu->AppendMenu(MF_SEPARATOR);
			pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
		}
	}

	SetIcon(m_hIcon, TRUE);			
	SetIcon(m_hIcon, FALSE);		

	// Desenvolvimento Aberto
	// Inicializa dialogo

	// Define variavel padrão para o banco de dados
	bancodedados = "oracle";

	// Cria o modelo de exibição de dados
	m_tabela.SetView(LV_VIEW_DETAILS);
	m_tabela.SendMessage(LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_GRIDLINES);

	return TRUE;  
}

void CAcessocppDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
	if ((nID & 0xFFF0) == IDM_ABOUTBOX)
	{
		CAboutDlg dlgAbout;
		dlgAbout.DoModal();
	}
	else
	{
		CDialogEx::OnSysCommand(nID, lParam);
	}
}

void CAcessocppDlg::OnPaint()
{
	if (IsIconic())
	{
		CPaintDC dc(this); 

		SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);

		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;

		dc.DrawIcon(x, y, m_hIcon);
	}
	else
	{
		CDialogEx::OnPaint();
	}
}

HCURSOR CAcessocppDlg::OnQueryDragIcon()
{
	return static_cast<HCURSOR>(m_hIcon);
}

// **************************
// * Desenvolvimento Aberto *
// **************************
// Nosso código começa aqui

// Seleciona banco de dados Oracle
void CAcessocppDlg::OnBnHotItemChangeRadio1(NMHDR *pNMHDR, LRESULT *pResult)
{
	LPNMBCHOTITEM pHotItem = reinterpret_cast<LPNMBCHOTITEM>(pNMHDR);
	
	bancodedados = "oracle";
	*pResult = 0;
}

// Seleciona banco de dados IBM DB2
void CAcessocppDlg::OnBnHotItemChangeRadio2(NMHDR *pNMHDR, LRESULT *pResult)
{	
	LPNMBCHOTITEM pHotItem = reinterpret_cast<LPNMBCHOTITEM>(pNMHDR);

	bancodedados = "db2";
	*pResult = 0;
}

// Seleciona banco de dados MSSQL
void CAcessocppDlg::OnBnHotItemChangeRadio3(NMHDR *pNMHDR, LRESULT *pResult)
{	
	LPNMBCHOTITEM pHotItem = reinterpret_cast<LPNMBCHOTITEM>(pNMHDR);

	bancodedados = "mssql";
	*pResult = 0;
}

// Evento de clique do botão
void CAcessocppDlg::OnBnClickedButton1()
{
	// campo de dado da tabela
	CString m_campo;

	// Abre conexão
	if (bancodedados == "oracle")
	{
		conectarDB(L"OracleXE", L"user", L"p@55w0rd");
	}

	if (bancodedados == "db2")
	{
		conectarDB(L"IBMDB2", L"user", L"p@55w0rd");
	}

	if (bancodedados == "mssql")
	{
		conectarDB(L"MSSQLSERVER", L"user", L"p@55w0rd");
	}

	// Cria um set de dados
	CRecordset  dados(&db);
	CString insereSql;


	// DB2 e Oracle utilizam sequence
	// SQL Server utiliza o Identity
	// Como é um objeto atrelado ao campo
	// Necessita ser suprimido da clausula SQL
	if (bancodedados != "mssql") 
	{

		insereSql = L"insert into SEQUENCIA VALUES (Sequencia_seq.NEXTVAL ,\'Teste\',\'Teste Sobrenome\',\'Programador\',2234.56)";

	}
	else
	{
		insereSql = L"insert into SEQUENCIA VALUES (\'Teste\',\'Teste Sobrenome\',\'Programador\',2234.56)";

	}
	
	// Executa instrução SQL
	db.ExecuteSQL(insereSql);
		
	// Declara instrução SQL
	CString sql = L"SELECT * FROM SEQUENCIA ORDER BY 1 DESC";

	// Abre set de dados
	dados.Open(CRecordset::forwardOnly, sql);

	// Cria item
	LVITEM lvItem;

	// cria estrutura para inserir o item
	typedef struct _LVITEM 
	{
		UINT mask;
		int iItem;
		int iSubItem;
		UINT state;
		UINT stateMask;
		LPTSTR pszText;
		int cchTextMax;
		int iImage;
		LPARAM lParam;
        #if (_WIN32_IE >= 0x0300)
		  int iIndent;
        #endif
	 } LVITEM, FAR *LPLVITEM;

	// Define variaveis de itens
	int InsertItem(const LVITEM* pItem);
	int nItem;

	// Converte CString para LPTSTR atraves de um TCHAR
	TCHAR sz[1024];
		
	// Verifica colunas
	short nFields = dados.GetODBCFieldCount();
	int colunas = m_tabela.GetHeaderCtrl()->GetItemCount();
	
	// Verifica colunas
	if (colunas == 0)
	{
		// Lê metadata da tabela
		CODBCFieldInfo field;
		for (UINT i = 0; i < nFields; i ++)
		{
			dados.GetODBCFieldInfo(i, field);
			m_tabela.InsertColumn(i, field.m_strName, LVCFMT_LEFT, 100);
		}

	}

	// Deleta itens do controle de lista
	m_tabela.DeleteAllItems();
	
	// Recupera dados da tabela
	while (!dados.IsEOF())
	{
		for (short index = 0; index < nFields; index++)
		{
			dados.GetFieldValue(index, m_campo);
			
			// Retorna linha do banco de dados
			if (index == 0)
			{
				// Insere linha
				lvItem.mask = LVIF_TEXT;
				lvItem.iItem = 0;
				lvItem.iSubItem = 0;
				lvItem.pszText = lstrcpy(sz, m_campo);
				nItem = m_tabela.InsertItem(&lvItem);
			}

			// Retorna colunas da linha
			m_tabela.SetItemText(nItem, index, lstrcpy(sz, m_campo));
					
		}
		// Move o cursor para a proxima linha
		dados.MoveNext();
	}

	// Fecha o set de dados e a conexão
	dados.Close();
	db.Close();
	 
}

void CAcessocppDlg::conectarDB(CString dns, CString usuario, CString senha)
{
	// Cria string de conexão ODBC
	CString conexao;
	
	// Cria string de conexão
	conexao = L"DSN=" + dns + L";UID=" + usuario + L";PWD=" + senha;

	// Abre conexão
	db.OpenEx(conexao, 0);	
}

Uma Sequence é um objeto de banco de dados encontrado nos bancos de dados Oracle e IBM DB2, que permite a geração automática de valores, tais como números de identificação. Sequências são ideais para a tarefa de gerar valores de chaves únicas. Os aplicativos podem usar sequências para evitar possíveis problemas de simultaneidade e de desempenho resultantes de valores de coluna. A vantagem que tem sobre as  sequências de números criados fora do banco de dados é que o servidor de banco de dados mantém o registro dos números gerados e nenhum tipo de acidente no banco de dados causará números duplicados.

Sequence - Identity - C#

Sequence – Identity – C#

Identity é encontrado no banco de dados Micosoft SQL Server e é muito similar ao Sequence e possui o mesmo objetivo que é de criar números sequenciais, porem não é um objeto do banco de dados e sim uma propriedade de uma coluna pertencente a uma tabela. Quando você insere um valor em uma tabela que possui uma propriedade Identity você deve excluir o campo referente a esta coluna da clausula SQL, sendo assim o MSSQL Server é o único banco de dados que permite que a quantidade de colunas na linha Values da instrução Insert seja diferente da quantidade de colunas na tabela do banco de dados.

sequence-3-sql-server

MSSQL – Identity – Propriedades

Para saber mais detalhes sobre os recursos dos objetos Sequences ou da propriedade Identity recomendamos que você utilize os links oficiais de cada banco de dados:

Oracle: Sequence
IBM DB2: Sequence
MSSQL Server: Identity

OBS: À partir da versão 2012 do MSSQL a microsoft também decidiu adotar Sequences para criar números auto incrementos, pois elas possuem vantagens em relação ao Identitiy que até nas versões atuais apresentam alguns problemas como pular a numeração automática inexplicavelmente.

Sequences MSSQLhttps://msdn.microsoft.com/pt-br/library/ff878091(v=sql.120).aspx

Algo extremamente útil sobre Sequence ou Identity

Utilizar um objeto ou uma propriedade auto incremento é o método correto para criar IDs automáticos no banco de dados, nunca utilize uma Trigger para executar este procedimento, pois deste modo você esta reduzindo sensivelmente a performance do banco de dados, visto que você precisa de acessos e objetos extras para executar a mesma função.

Para valores de Sequence ou Identity que são utilizados fora do banco de dados, por exemplo, números de sequência usados ​​para identificadores externos (números de cheques bancários ou outros), se o banco de dados é recuperado para um ponto no tempo antes de uma falha, então isso poderia causar a geração de valores duplicados para algumas sequências. Para evitar possíveis valores duplicados, bancos de dados que usam valores de sequência fora do banco de dados não deve ser recuperado para um ponto anterior no tempo.

Visual Studio

Para criar a conexão com os três bancos de dados você precisa configurar seu projeto com os Providers externos de cada um dos fabricantes, você encontra um tutorial de como criar as conexões em nossas categorias SQL e C# e depois você pode criar um design com 3 componentes RadioButton, 1 componentes Labels, um componente Button e um componente DataGridView use a figura abaixo para referencia:

Visual Studio - design

Visual Studio – design

Conectando ao Oracle, DB2 e MSSQL

Para efetuar a conexão com os três bancos de dados utilizamos a classe DbProviderFactory e as classes comuns para conexão e manipulação de dados contidas no namespace chamado System.Data.Common, que são classes genéricas equivalentes as classes no qual já utilizamos de um modo nativo para cada provedor de banco de dados nos exemplos anteriores, as classes comuns são:  DbConnection, DbCommand e DbDataReader.

DbProviderFactory

Representa um conjunto de métodos para criar instâncias de implementação de classes de provedor de dados. O processo de obter DbProviderFactory envolve passar informações sobre um provedor de dados para a classe DbProviderFactories.  Com base nessas informações, o método GetFactory cria uma fábrica de provedor fortemente tipada.

As classes OracleClientFactory, OdbcFactory e OleDbFactory do .NET Framework também oferecem funcionalidade semelhante.

Atente-se que qualquer cliente Oracle ADO.NET das classes contidas no namespace System.Data.OracleClient é um provedor obsoleto, veja comentário e link para consulta no código fonte.

Exemplo:

Neste exemplo utilizamos uma Sequence para os bancos de dados Oracle e IBM DB2 e uma propriedade Identity para o banco de dados MSSQL para criar identificadores automáticos para a coluna chave de uma tabela.

SQL

Oracle

-- Cria sequencia
CREATE SEQUENCE Sequencia_seq
 START WITH     1
 INCREMENT BY   1
 NOCACHE
 NOCYCLE;

-- Cria tabela
CREATE TABLE SEQUENCIA (
   Identificador   NUMBER(10),
   Nome            VARCHAR(30),
   Sobrenome       VARCHAR(70),
   Cargo           VARCHAR(30),
   Salario         Decimal(9,2));

 -- Testa sequencia
insert into SEQUENCIA VALUES (Sequencia_seq.NEXTVAL ,'Teste','Teste Sobrenome','Programador',2234.56);

-- verifica resultado
SELECT * FROM SEQUENCIA

IBM DB2

-- Cria Sequencia
CREATE SEQUENCE Sequencia_seq
 START WITH     1
 INCREMENT BY   1
 NOCACHE
 NOCYCLE;

-- Cria tabela
CREATE TABLE SEQUENCIA (
   Identificador   INTEGER,
   Nome            VARCHAR(30),
   Sobrenome       VARCHAR(70),
   Cargo           VARCHAR(30),
   Salario         Decimal(9,2));

 -- Testa Sequencia
insert into SEQUENCIA VALUES (Sequencia_seq.NEXTVAL ,'Teste','Teste Sobrenome','Programador',2234.56);

-- Verifica resultado
Select * from SEQUENCIA;

MSSQL

-- Cria tabela / Identity
CREATE TABLE SEQUENCIA(
	Identificador int IDENTITY(1,1) NOT NULL,
	Nome          nvarchar(30) NULL,
	Sobrenome     nvarchar(70) NULL,
	Cargo         nvarchar(30) NULL,
	Salario       decimal(9, 2) NULL);

-- Testa identação
insert into SEQUENCIA VALUES ('Teste','Teste Sobrenome','Programador',2234.56);

-- Verifica tabela
select * from SEQUENCIA;

C#

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Data.SqlClient;    // ADO.NET
using Oracle.DataAccess.Client; // ODAC 12c
using IBM.Data.DB2;             // IBM Data Server Provider
using System.Data.Common;       // ADO Comum

namespace Acesso
{
    public partial class Dados : Form
    {
        // Conexão Unica (Factory)
        private static DbConnection connUnica = null;
        private static DbProviderFactory factory;

        DataTable dataTable;

        string sql;
        static string bancodedados;

        public Dados()
        {
            InitializeComponent();
        }

        // ************** Sobre Conexões - ADO.NET **************
        //
        // A Microsoft disponibiliza por exemplo, o System.Data.OracleClient
        // porem se tornou obsoleto e ainda é suportado somente
        // a nível de compatibilidade com versões anteriores do Framework.
        // A Microsoft recomenda utilizar o driver de cada fornecedor:
        //
        // veja: http://msdn.microsoft.com/en-us/library/77d8yct7.aspx
        //
        // Você pode utilizar a classe DbProviderFactory
        // para criar um único datasource para todos os bancos de dados:
        //
        // http://msdn.microsoft.com/pt-br/library/system.data.common.dbproviderfactory(v=vs.110).aspx
        //
        // No entanto diferentemente da linguagem JAVA (JDBC) o ADO.NET não suporta
        // alguns recursos do Oracle e IBM DB2.
        //
        // *** Factory ***
        //
        // Utilizando conexões únicas de cada provedor de banco de dados
        // através de um Factory, permite que você utilize um único set de instruções
        // para todos os bancos de dados.
        //
        // Atente-se que se utilizar instruções únicas, em alguns casos poderá encontrar
        // alguns erros de compatibilidade ou criar certas limitações a outros bancos.
        // O ADO.NET é desenvolvido para o MSSQL Server e está sujeito
        // a algumas limitações quando utilizar alguns tipos de campos,
        // conceitos de conexão e acesso a dados de outros bancos de dados.
        //
        // Sistemas de grande porte possuem um Dicionário de dados
        // para se prevenir destas situações.
        //
        // Neste exemplos utilizamos DbProviderFactory e a Classe comum pertencendte ao
        // namespaces: System.Data.Common para criar um set de instruções comuns para todos os bancos de dados.


        // *** String de Conexão ***
        // Devido ao conceito de Database/User e TNS Names do Oracle
        // precisamos de uma função Override para outros bancos de dados com conceito de Database comum.
        // caso deseje montar a String de conexão utilizando parâmetros em um método.
        public void conexaoUnica(string Username, string Password, string Datasource)
        {

            string connectionString;

            if (bancodedados == "oracle")
            {
                try
                {
                    // String de Conexao
                    connectionString =

                    // Usuario
                    "User Id=" + Username +

                    // Senha
                    ";Password=" + Password +

                    // TNSnames
                    ";Data Source=" + Datasource;

                    // ODAC 12c
                    factory = DbProviderFactories.GetFactory("Oracle.DataAccess.Client");

                    connUnica = factory.CreateConnection();
                    connUnica.ConnectionString = connectionString;
                    connUnica.Open();
                }

                 catch (Exception ex)
                {
                     // Mostra menssagem de erro
                     MessageBox.Show(ex.ToString());
                }
            }
        }

        // Metodo Override para conexão IBM DB2 e MSSQL

        public void conexaoUnica(string Server, string Database,
                                    string Username, string Password, string Timeout)
        {

            string connectionString;

            if (bancodedados == "db2")
            {
                try
                {
                    // String de Conexao
                    connectionString =

                    // Servidor
                    "Server=" + Server +

                    // Banco de dados
                    ";Database=" + Database +

                    // Usuario
                    ";UID=" + Username +

                    // Senha
                    ";PWD=" + Password +

                    // TNSnames
                    ";Connect Timeout=" + Timeout;

                    // IBM DATA Server Provider
                    factory = DbProviderFactories.GetFactory("IBM.Data.DB2");

                    connUnica = factory.CreateConnection();
                    connUnica.ConnectionString = connectionString;
                    connUnica.Open();
                }

                catch (Exception ex)
                {
                    // Mostra menssagem de erro
                    MessageBox.Show(ex.ToString());
                }
            }

            if (bancodedados == "mssql")
            {
                try
                {
                    // String de Conexao
                    connectionString =

                    // Servidor
                    "Server=" + Server +

                    // Banco de dados
                    ";Database=" + Database +

                    // Usuario
                    ";UID=" + Username +

                    // Senha
                    ";PWD=" + Password +

                    // TNSnames
                    ";Connect Timeout=" + Timeout;

                    // ADO NET Nativo - MSSQL Server
                    factory = DbProviderFactories.GetFactory("System.Data.SqlClient");

                    connUnica = factory.CreateConnection();
                    connUnica.ConnectionString = connectionString;
                    connUnica.Open();
                }

                catch (Exception ex)
                {
                    // Mostra menssagem de erro
                    MessageBox.Show(ex.ToString());
                }
            }

        }     

        // Retorna um set de dados
         public  DataTable retornaTabela(string sql, string inserir)
         {
             // Cria instância da classe
             Dados acesso = new Dados();

             // Define banco de dados
             // Efetua Login no banco de dados

             if (bancodedados == "oracle")
             {
                 acesso.conexaoUnica("user", "p@55w0rd", "XE");
             }

             if (bancodedados == "db2")
             {
                 acesso.conexaoUnica("localhost", "DEVA", "user", "p@55w0rd", "40");
             }

             if (bancodedados == "mssql")
             {
                 acesso.conexaoUnica("localhost", "DevAberto", "user", "p@55w0rd", "");
             }

                 // Define a instrução SQL e a conexão
                 DbCommand cmdUnicoInsere = factory.CreateCommand();
                 cmdUnicoInsere.Connection = connUnica; ;
                 cmdUnicoInsere.CommandText = inserir;
                 cmdUnicoInsere.ExecuteNonQuery();

                 DbCommand cmdUnico = factory.CreateCommand();
                 cmdUnico.Connection = connUnica; ;
                 cmdUnico.CommandText = sql;

                 // Cria comandos para retornar dados para exibir a grade de dados

                 DbDataReader uReader = cmdUnico.ExecuteReader();
                 dataTable = new DataTable();
                 dataTable.Load(uReader);

             return  dataTable;

         }

        // configura programa
        private void Form1_Shown(object sender, EventArgs e)
        {
            radioButton1.Checked = true;
            bancodedados = "oracle";
        }

        // Conecta dados
        private void button1_Click(object sender, EventArgs e)
        {
            // Declara variavel SQL
            string insere;

            // Cria instância da classe
            Dados dados = new Dados();

            // Seleciona dados da tabela
            sql = "SELECT * FROM SEQUENCIA ORDER BY 1";

            // DB2 e Oracle utilizam sequence
            // SQL Server utiliza o Identity
            // Como é um objeto atrelado ao campo
            // Necessita ser suprimido da clausula SQL

            if (bancodedados != "mssql")
            {
                insere = "insert into SEQUENCIA VALUES (Sequencia_seq.NEXTVAL ,\'Teste\',\'Teste Sobrenome\',\'Programador\',2234.56)";
            }
            else
            {
                insere = "insert into SEQUENCIA VALUES (\'Teste\',\'Teste Sobrenome\',\'Programador\',2234.56)";
            }

            // Alimenta grid de dados
            dataGridView1.DataSource = dados.retornaTabela(sql, insere);

        }

        // Seleciona banco de dados Oracle
        private void radioButton1_CheckedChanged(object sender, EventArgs e)
        {
            if (radioButton1.Checked)
            {
                bancodedados = "oracle";
            }

        }

        // Seleciona banco de dados IBM DB2
        private void radioButton2_CheckedChanged(object sender, EventArgs e)
        {
            if (radioButton2.Checked)
            {
                bancodedados = "db2";
            }
        }

        // Seleciona banco de dados MSSQL Server
        private void radioButton3_CheckedChanged(object sender, EventArgs e)
        {
            if (radioButton3.Checked)
            {
                bancodedados = "mssql";
            }
        }
    }
}

Uma Sequence é um objeto de banco de dados encontrado nos bancos de dados Oracle e IBM DB2, que permite a geração automática de valores, tais como números de identificação. Sequências são ideais para a tarefa de gerar valores de chaves únicas. Os aplicativos podem usar sequências para evitar possíveis problemas de simultaneidade e de desempenho resultantes de valores de coluna. A vantagem que tem sobre as  sequências de números criados fora do banco de dados é que o servidor de banco de dados mantém o registro dos números gerados e nenhum tipo de acidente no banco de dados causará números duplicados.

Sequence - Identity - Java

Sequence – Identity – Java

Identity é encontrado no banco de dados Micosoft SQL Server e é muito similar ao Sequence e possui o mesmo objetivo que é de criar números sequenciais, porem não é um objeto do banco de dados e sim uma propriedade de uma coluna pertencente a uma tabela. Quando você insere um valor em uma tabela que possui uma propriedade Identity você deve excluir o campo referente a esta coluna da clausula SQL, sendo assim o MSSQL Server é o único banco de dados que permite que a quantidade de colunas na linha Values da instrução Insert seja diferente da quantidade de colunas na tabela do banco de dados.

sequence-3-sql-server

MSSQL – Identity – Propriedades

Para saber mais detalhes sobre os recursos dos objetos Sequences ou da propriedade Identity recomendamos que você utilize os links oficiais de cada banco de dados:

Oracle: Sequence
IBM DB2: Sequence
MSSQL Server: Identity

Algo extremamente útil sobre Sequence ou Identity

Utilizar um objeto ou uma propriedade auto incremento é o método correto para criar IDs automáticos no banco de dados, nunca utilize uma Trigger para executar este procedimento, pois deste modo você esta reduzindo sensivelmente a performance do banco de dados, visto que você precisa de acessos e objetos extras para executar a mesma função.

Para valores de Sequence ou Identity que são utilizados fora do banco de dados, por exemplo, números de sequência usados ​​para identificadores externos (números de cheques bancários ou outros), se o banco de dados é recuperado para um ponto no tempo antes de uma falha, então isso poderia causar a geração de valores duplicados para algumas sequências. Para evitar possíveis valores duplicados, bancos de dados que usam valores de sequência fora do banco de dados não deve ser recuperado para um ponto anterior no tempo.

Conectando ao Oracle, DB2 e MSSQL

Para criar a conexão com os três bancos de dados você precisa configurar seu projeto com os Providers externos de cada um dos fabricantes, você encontra um tutorial de como criar as conexões em nossas categorias SQL e Java

Conexão - External Jars

Conexão – External Jars

Exemplo:

Neste exemplo utilizamos uma Sequence para os bancos de dados Oracle e IBM DB2 e uma propriedade Identity para o banco de dados MSSQL para criar identificadores automáticos para a coluna chave de uma tabela.

SQL

Oracle

-- Cria sequencia
CREATE SEQUENCE Sequencia_seq
 START WITH     1
 INCREMENT BY   1
 NOCACHE
 NOCYCLE;

-- Cria tabela
CREATE TABLE SEQUENCIA (
   Identificador   NUMBER(10),
   Nome            VARCHAR(30),
   Sobrenome       VARCHAR(70),
   Cargo           VARCHAR(30),
   Salario         Decimal(9,2));

 -- Testa sequencia
insert into SEQUENCIA VALUES (Sequencia_seq.NEXTVAL ,'Teste','Teste Sobrenome','Programador',2234.56);

-- verifica resultado
SELECT * FROM SEQUENCIA

IBM DB2

-- Cria Sequencia
CREATE SEQUENCE Sequencia_seq
 START WITH     1
 INCREMENT BY   1
 NOCACHE
 NOCYCLE;

-- Cria tabela
CREATE TABLE SEQUENCIA (
   Identificador   INTEGER,
   Nome            VARCHAR(30),
   Sobrenome       VARCHAR(70),
   Cargo           VARCHAR(30),
   Salario         Decimal(9,2));

 -- Testa Sequencia
insert into SEQUENCIA VALUES (Sequencia_seq.NEXTVAL ,'Teste','Teste Sobrenome','Programador',2234.56);

-- Verifica resultado
Select * from SEQUENCIA;

MSSQL

-- Cria tabela / Identity
CREATE TABLE SEQUENCIA(
	Identificador int IDENTITY(1,1) NOT NULL,
	Nome          nvarchar(30) NULL,
	Sobrenome     nvarchar(70) NULL,
	Cargo         nvarchar(30) NULL,
	Salario       decimal(9, 2) NULL);

-- Testa identação
insert into SEQUENCIA VALUES ('Teste','Teste Sobrenome','Programador',2234.56);

-- Verifica tabela
select * from SEQUENCIA;

Java

import java.awt.Container;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Vector;

import javax.swing.BorderFactory;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.ButtonGroup;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.table.DefaultTableModel;

public class Sequence implements ActionListener, ItemListener {
    // Cria componentes
    private JTable tabela;
    private JRadioButton banco1;
    private JRadioButton banco2;
    private JRadioButton banco3;
    private JButton botao;

    // Declara objetos de conexão
    private static Connection conn;
    private static Statement query;
    private static String bancodedados;

    public void conectar(String login, String senha) {

        // Verifica strings de conexão

        // ORACLE
        if (bancodedados == "oracle") {
            try {
                // Define Driver de conexão JDBC thin
                Class.forName("oracle.jdbc.driver.OracleDriver");
                conn = DriverManager.getConnection(
                        "jdbc:oracle:thin:@localhost:1521:xe", login, senha);

                // Executa pedido SQL
                query = conn.createStatement();

            }

            catch (ClassNotFoundException ex) {
                ex.printStackTrace();
            }

            catch (SQLException ex) {
                ex.printStackTrace();
            }
        }

        // DB2
        if (bancodedados == "db2") {
            try {
                // Define Driver de conexão JDBC
                Class.forName("com.ibm.db2.jcc.DB2Driver");
                conn = DriverManager.getConnection(
                        "jdbc:derby:net://localhost:50000/deva", login, senha);

                // Executa pedido SQL
                query = conn.createStatement();
            }

            catch (ClassNotFoundException ex) {
                ex.printStackTrace();
            }

            catch (SQLException ex) {
                 ex.printStackTrace();
            }

        }

        // MICROSOFT SQL SERVER
        if (bancodedados == "mssql") {
            try {
                // Define Driver de conexão JDBC
                String URL = "jdbc:sqlserver://localhost\\SQLEXPRESS:1433;databaseName=devaberto"
                        + ";user=" + login + ";password=" + senha;

                Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
                conn = DriverManager.getConnection(URL);

                // Executa pedido SQL
                query = conn.createStatement();

            }

            catch (ClassNotFoundException ex) {
                ex.printStackTrace();
            }

            catch (SQLException ex) {
                ex.printStackTrace();
            }

        }

    }

    public void executaSQL(String sql)   {
        // Cria nova instrução SQL
        Statement trigger;
        ;
        try {
            trigger = conn.createStatement();
            trigger.execute(sql);
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public ResultSet retornaTabela() throws SQLException {
        // Cria nova instrução SQL
        Statement query;
        query = conn.createStatement();
        String sql;

        // Verfica banco de dados e passa script SQL
        sql = "SELECT * FROM SEQUENCIA";

        // Executa Script
        ResultSet dados = query.executeQuery(sql);

        // Retorna set de dados
        return dados;
    }

    // Modelo
    public static DefaultTableModel criaTableModel(ResultSet rs)
            throws SQLException {

        // Cria um modelo de tabela
        ResultSetMetaData metaData = rs.getMetaData();

        // Retorna as colunas
        Vector<String> colunas = new Vector<String>();

        int columnCount = metaData.getColumnCount();

        for (int column = 1; column <= columnCount; column++) {
            colunas.add(metaData.getColumnName(column));
        }

        // Retorna dados
        Vector<Vector<Object>> dados = new Vector<Vector<Object>>();

        while (rs.next()) {
            Vector<Object> vector = new Vector<Object>();

            for (int columnIndex = 1; columnIndex <= columnCount; columnIndex++) {
                vector.add(rs.getObject(columnIndex));
            }
            dados.add(vector);
        }

        return new DefaultTableModel(dados, colunas);

    }

    public void itemStateChanged(ItemEvent arg0) {

        // Verifica item banco de dados selecionado
        Object fonte = arg0.getItemSelectable();
        int estado = arg0.getStateChange();

        if (estado == arg0.SELECTED) {

            if (fonte == banco1) {
                bancodedados = "oracle";
            }

            if (fonte == banco2) {
                bancodedados = "db2";
            }

            if (fonte == banco3) {
                bancodedados = "mssql";
            }

        }

    }

    public void actionPerformed(ActionEvent arg0) {
        // Efetua login no banco de dados
    	Sequence acesso = new Sequence();

        if (bancodedados == "oracle") {
            acesso.conectar("user", "p@55w0rd");
        }

        if (bancodedados == "db2") {
            acesso.conectar("user", "p@55w0rd");
        }

        if (bancodedados == "mssql") {
            acesso.conectar("user", "p@55w0rd");
        }

        try {

        	// DB2 e Oracle utilizam sequence
        	// SQL Server utiliza o Identity
        	// Como é um objeto atrelado ao campo
        	// Necessita ser suprimido da clausula SQL

        	if (bancodedados != "mssql")
        	{
        		acesso.executaSQL("insert into SEQUENCIA VALUES (Sequencia_seq.NEXTVAL ,\'Teste\',\'Teste Sobrenome\',\'Programador\',2234.56)");
        	}
        	else
        	{
        		acesso.executaSQL("insert into SEQUENCIA VALUES (\'Teste\',\'Teste Sobrenome\',\'Programador\',2234.56)");
        	}

            // Executa Intrução SQL
            tabela.setModel(criaTableModel(acesso.retornaTabela()));
        } catch (SQLException e) {
            e.printStackTrace();
        }

    }

    public Container criaPainel() throws SQLException {
        // Cria painel principal
        JPanel painel = new JPanel();

        // Seleciona layout
        painel.setLayout(new BoxLayout(painel, BoxLayout.PAGE_AXIS));
        painel.setBorder(BorderFactory.createEmptyBorder(20, 20, 20, 20));

        // Cria painel de escolha de conexão
        JPanel pescolha = new JPanel();

        pescolha.setLayout(new BoxLayout(pescolha, BoxLayout.LINE_AXIS));
        pescolha.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));

        ButtonGroup grupo = new ButtonGroup();

        // Cria componentes de radio
        banco1 = new JRadioButton("Oracle");
        banco2 = new JRadioButton("IBM DB2");
        banco3 = new JRadioButton("Microsoft SQL");

        // Agrupa botões de radio
        grupo.add(banco1);
        grupo.add(banco2);
        grupo.add(banco3);

        // Cria ouvinte dos botões
        banco1.addItemListener(this);
        banco2.addItemListener(this);
        banco3.addItemListener(this);

        // Seleciona primeira conexão
        banco1.setSelected(true);

        // Adiciona botões ao painel
        pescolha.add(banco1);
        pescolha.add(banco2);
        pescolha.add(banco3);

        // Efetua primeira conexão ao banco (ORACLE)
        // caso queira mudar a conexão
        // mude o indice dos componentes de radio
        Sequence acesso = new Sequence();

        acesso.conectar("user", "p@55w0rd");

        // Cria modelo de tabela
        tabela = new JTable(criaTableModel(acesso.retornaTabela()));

        // Adiciona um painel de rolagem
        JScrollPane rolar = new JScrollPane(tabela);

        // Cria painel do botão
        JPanel pbotao = new JPanel(new GridLayout(0, 3, 10, 10));       

        botao = new JButton("Cria Sequence/Identity");
        botao.addActionListener(this);

        // Adiciona botão ao painel

        pbotao.add(Box.createHorizontalStrut(10));
        pbotao.add(Box.createHorizontalStrut(10));
        pbotao.add(botao);

        // componentes ao painel principal
        painel.add(pescolha);
        painel.add(rolar);
        painel.add(Box.createVerticalStrut(10));
        painel.add(pbotao);

        return painel;
    }

    public static void criaGUI() {
        // Cria formulario
        JFrame formulario = new JFrame("Desenvolvimento Aberto - Sequence / Identity");
        formulario.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        // cria painel de conteudo
        Sequence acesso = new Sequence();

        try {
            formulario.setContentPane(acesso.criaPainel());
        }

        catch (SQLException e) {
            e.printStackTrace();
        }

        // Exibe o formulario
        formulario.setSize(700, 300);
        formulario.setVisible(true);
    }

    public static void main(String[] args) {
        javax.swing.SwingUtilities.invokeLater(new Runnable() {

            @Override
            public void run() {

                // Cria e mostra a GUI
                criaGUI();
            }
        });
    }
}

Você pode desenvolver aplicações escritas para o .NET Framework no Microsoft Visual Studio e utilizar os arquivos executáveis (“binários”) compilados no sistema operacional Windows, rodando-os diretamente no sistema operacional Linux através do Framework Mono.

O Mono contém as bibliotecas de desenvolvimento do núcleo do Framework da Microsoft e as ferramentas de desenvolvimento e implantação necessárias para portar suas funcionalidades, entretanto existe algumas limitações de portabilidade devido aos conceitos de cada sistema operacional, mas existe uma série de estratégias que você pode adotar, dependendo de como você está confortável com o uso do Linux.

Application Portability: http://www.mono-project.com/docs/getting-started/application-portability/

Distribuindo o Mono

Você pode distribuir o Framework Mono no Linux de um modo fácil, sem precisar ter contato manual com o repositório do projeto, utilizando um PPA (Personal Package Archive), o PPA é uma plataforma para disponibilizar pacotes de softwares empacotados por desenvolvedores para usuários do Ubuntu, você encontra os PPAs no site Launchpad, mantido pela empresa Canonical que é a desenvolvedora do Ubuntu Linux. Utilize as instruções abaixo no terminal do Linux para instalar o Framework Mono:

sudo apt-get install software-properties-common
sudo add-apt-repository ppa:inizan-yannick/mono
sudo apt-get update
sudo apt-get install mono-devel

Testando a Portabilidade: Windows – Linux

Para efetuar um teste de portabilidade, vamos criar uma aplicação básica no sistema operacional Windows utilizando o Microsoft Visual Studio, vamos escrever uma aplicação Windows Forms dinamicamente, utilizando algumas técnicas especificas, como alguns Event Handlers dinâmicos, Hot Keys e a previsão de teclas (Key Preview) do Windows e portar o aplicativo compilado que será executado no sistema operacional Linux.

1 – Crie uma nova solução Windows Forms chamada PortabilidadeCs e quando o formulário aparecer na tela aperte a tecla F7 para ir para a unidade de código csharp, troque o código da classe gerada automaticamente pelo código encontrado abaixo:

Windows - Aplicação - Visual Studio

Windows – Aplicação – Visual Studio

2 – Compile e teste seu aplicativo, atente-se para o recurso de previsão de teclas do Windows utilizando as teclas A, B, C e D e também o recurso de teclas de atalhos utilizando as teclas ALT + A e assim por diante:

Aplicação - C# - .NET - Windows

Aplicação – C# – .NET – Windows

3 – Após testar sua aplicação envie uma cópia do arquivo compilado PortabilidadeCS.exe para o sistema operacional Linux, você pode utilizar o método de sua preferencia para efetuar esta operação :

Aplicativo - C# - Linux

Aplicativo – C# – Linux

4 – Quando o Framework Mono está instalado no Linux, o sistema operacional reconhece arquivos de extensão EXE criados no .NET Framework como um arquivo executável do Linux. Utilize um duplo clique para executar sua aplicação C#:

C# - Portabilidade - Windows - Linux

C# – Portabilidade – Windows – Linux

Você pode perceber que todas as funcionalidades básicas do formulário funcionam perfeitamente. Agora você já pode portar suas aplicações Windows para outras plataformas, tenha em mente que você deve seguir sempre as melhores praticas para o desenvolvimento e respeitar as diferentes tecnologias de cada sistema operacional.

Uma opção é encontrar um meio termo para que suas aplicações .NET cruzem as mais diferentes plataformas sem que você tenha que reescrever seu código, por exemplo a tecnologia COM para Windows, mais especificamente DCOM é equivalente a tecnologia CORBA para Linux, porem é possível utilizar CORBA no Windows e portar seus aplicativos sem reescrever os arquivos binários que interagem entre si, dentro é claro, das diferenças e limitações existentes entre as duas tecnologias.

Corba: http://www.corba.org/

As classes comuns de pedido de arquitetura (CORBA) Broker são convertidas para as classes no namespace: System.Runtime.Remoting

Remoting: http://msdn.microsoft.com/pt-br/library/system.runtime.remoting(v=vs.110).aspx

Exemplo:

Neste exemplo criamos uma aplicação C# no Microsoft Visual Studio e a rodamos no sistema operacional Linux através do Framework Mono utilizando o mesmo arquivo “binário”.

C#

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace PortabiliadeCs
{
    public partial class Form1 : Form
    {
        // Define componentes dinamicamente
        Label rotulo;
        RadioButton soma;
        RadioButton subtrai;
        RadioButton multiplica;
        RadioButton divide;
        Label rotulo1;
        TextBox campo1;
        Label rotulo2;
        TextBox campo2;
        Button botao;
        TextBox texto;
        double total;

        public Form1()
        {
            InitializeComponent();

            // Evento OnShown do Formulario
            this.Shown += new System.EventHandler(this.Form1_Shown);
        }

        private void Form1_Shown(object sender, EventArgs e)
        {
            // Cria componentes dinamicamente no evento form shown
            rotulo = new Label();
            soma = new RadioButton();
            subtrai = new RadioButton();
            multiplica = new RadioButton();
            divide = new RadioButton();
            rotulo1 = new Label();
            campo1 = new TextBox();
            rotulo2 = new Label();
            campo2 = new TextBox();
            botao = new Button();
            texto = new TextBox();

            // posiciona componentes no form
            rotulo.Location = new Point(5, 10);
            soma.Location = new Point(5, 30);
            subtrai.Location = new Point(5, 50);
            multiplica.Location = new Point(5, 70);
            divide.Location = new Point(5, 90);
            rotulo1.Location = new Point(5, 120);
            campo1.Location = new Point(60, 120);
            rotulo2.Location = new Point(170, 120);
            campo2.Location = new Point(220, 120);
            botao.Location = new Point(330, 120);
            texto.Location = new Point(5, 150);

            // adiciona a propriedade de texto nos componentes
            rotulo.Text = "Escolha um RadioButton ou pressione (A, B, C ou D) ou (Alt + A, B, C ou D)";
            soma.Text = "Som&a";
            subtrai.Text = "Su&btrai";
            multiplica.Text = "Multipli&ca";
            divide.Text = "&Divide";
            rotulo1.Text = "Numero:";
            rotulo2.Text = "Numero:";
            botao.Text = "OK";

            // seta a propriedades para a caixa de texto
            texto.Multiline = true;
            texto.ScrollBars = ScrollBars.Vertical;
            texto.ReadOnly = true;

            // Define o tamanho dos objetos no form
            Form1.ActiveForm.Size = new Size(550, 400);
            rotulo.Size = new Size(450, 20);
            soma.Size = new Size(130, 20);
            subtrai.Size = new Size(130, 20);
            multiplica.Size = new Size(130, 20);
            divide.Size = new Size(130, 20);
            texto.Size = new Size(410, 100);
            rotulo1.Size = new Size(50, 20);
            rotulo2.Size = new Size(50, 20);
            texto.Size = new System.Drawing.Size(520, 200);

            // Define eventos para o checkbox
            soma.CheckedChanged += new System.EventHandler(soma_CheckedChanged);
            subtrai.CheckedChanged += new System.EventHandler(subtrai_CheckedChanged);
            multiplica.CheckedChanged += new System.EventHandler(multiplica_CheckedChanged);
            divide.CheckedChanged += new System.EventHandler(divide_CheckedChanged);
            botao.Click += new System.EventHandler(botao_Click);

            // Ativa a previsão de teclas do formulario
            Form1.ActiveForm.KeyPreview = true;

            // Nome do formulario
            Form1.ActiveForm.Text = "Desenvolvimento Aberto - Portabilidade Windows - Linux";

            // Adiciona componentes ao formulario
            Form1.ActiveForm.Controls.Add(rotulo);
            Form1.ActiveForm.Controls.Add(soma);
            Form1.ActiveForm.Controls.Add(subtrai);
            Form1.ActiveForm.Controls.Add(multiplica);
            Form1.ActiveForm.Controls.Add(divide);
            Form1.ActiveForm.Controls.Add(rotulo1);
            Form1.ActiveForm.Controls.Add(campo1);
            Form1.ActiveForm.Controls.Add(rotulo2);
            Form1.ActiveForm.Controls.Add(campo2);
            Form1.ActiveForm.Controls.Add(botao);
            Form1.ActiveForm.Controls.Add(texto);

        }

        // Eventos de Click dos botões
        private void botao_Click(object sender, EventArgs e)
        {
            if (soma.Checked)
            {
                total = Convert.ToDouble(campo1.Text) + Convert.ToDouble(campo2.Text);
                texto.AppendText(campo1.Text + " + " + campo2.Text + " = " + total + "\n");
            }

            if (subtrai.Checked)
            {
                total = Convert.ToDouble(campo1.Text) - Convert.ToDouble(campo2.Text);
                texto.AppendText(campo1.Text + " - " + campo2.Text + " = " + total + "\n");
            }

            if (multiplica.Checked)
            {
                total = Convert.ToDouble(campo1.Text) * Convert.ToDouble(campo2.Text);
                texto.AppendText(campo1.Text + " * " + campo2.Text + " = " + total + "\n");
            }

            if (divide.Checked)
            {
                total = Convert.ToDouble(campo1.Text) / Convert.ToDouble(campo2.Text);
                texto.AppendText(campo1.Text + " / " + campo2.Text + " = " + total + "\n");
            }
        }

        // Eventos do RadioButton - mudança de estado
        // Verifica o estado do componente pois este evento é executado duas vezes
        // 1 - Quando o botão é selecionado e
        // 2 - Quando o botão é deselecionado

        private void soma_CheckedChanged(object sender, EventArgs e)
        {
            if (soma.Checked)
            {
                texto.AppendText("Soma:\n");
            }
        }

        private void subtrai_CheckedChanged(object sender, EventArgs e)
        {
            if (subtrai.Checked)
            {
                texto.AppendText("Subtração:\n");
            }
        }
        private void multiplica_CheckedChanged(object sender, EventArgs e)
        {
            if (multiplica.Checked)
            {
                texto.AppendText("Multiplicação:\n");
            }
        }

        private void divide_CheckedChanged(object sender, EventArgs e)
        {
            if (divide.Checked)
            {
                texto.AppendText("Divisão:\n");
            }
        }     

        // Evento de tecla pressionada (Key Preview)
        private void Form1_KeyDown(object sender, KeyEventArgs e)
        {

            if (e.KeyCode == Keys.A)
            {

                if (soma.Checked == true)
                {
                    soma.Checked = false;
                }
                else
                {
                    soma.Checked = true;
                }

            }
            if (e.KeyCode == Keys.B)
            {

                if (subtrai.Checked == true)
                {
                    subtrai.Checked = false;
                }
                else
                {
                    subtrai.Checked = true;
                }

            }

            if (e.KeyCode == Keys.C)
            {

                if (multiplica.Checked == true)
                {
                    multiplica.Checked = false;
                }
                else
                {
                    multiplica.Checked = true;
                }

            }

            if (e.KeyCode == Keys.D)
            {

                if (divide.Checked == true)
                {
                    divide.Checked = false;
                }
                else
                {
                    divide.Checked = true;
                }

            }

        }
    }
}

PyDev – Eclipse IDE for Python – Linux

Publicado: 21 de setembro de 2014 em Python

O Eclipse é uma plataforma de desenvolvimento de software livre extensível, baseada em Java, que foi desenvolvido à partir de uma contribuição inicial do código da IBM, o Eclipse cresceu para um ecossistema de software livre completo com participação de mais de cem empresas unidas para criar uma estrutura de software livre extensível, móvel, com um design maduro, robusto e elegante, o Eclipse traz à tona toda uma nova dinâmica. Por si só, é simplesmente uma estrutura e um conjunto de serviços para desenvolvimento de aplicativos de componentes de plug-in.

PyDev é uma IDE Python para Eclipse, que pode ser usado em Python, Jython, desenvolvimento IronPython e Django. A IDE utiliza técnicas avançadas de inferência de tipos para fornecer recursos como conclusão de código e análise de código, enquanto ainda fornece muitos outros recursos, como depurador, console interativo, refactoring e muitos outros.

Saiba sobre o IBM Eclipse: Plataforma Eclipse

Saiba sobre o PyDev: http://pydev.org/

Download: Eclipse Java EE

Instalando o PyDev – Eclipse IDE for Python

Instalar o PyDev é muito simples basta ter qualquer versão da plataforma Eclipse superior ou igual a versão 3.7.1, para instalar o Eclipse no Linux você precisa ter o Java Runtime instalado. Para não ter problemas com o menu do Eclipse no Ubuntu, utilize a linha abaixo para descompactar o Eclipse.

Instala Java Runtime:
sudo add-apt-repository ppa:webupd8team/java
sudo apt-get update
sudo apt-get install oracle-java7-installer

Descompacta Eclipse Ubuntu:
tar xzvf eclipse-cpp-luna-R-linux-gtk-x86_64.tar.gz

1 – Abra sua versão do Eclipse e feche a janela Welcome:

Eclipse - Bem-vindo

Eclipse – Bem-vindo

2 – No menu Help escolha Install New Software, em Work With coloque o seguinte endereço e tecle Enter, aguarde o Eclipse encontrar o software, selecione PyDev e clique em Next: http://pydev.org/updates

3 – Selecione o Software encontrado e clique em Next:

PyDev Eclipse IDE for Python

PyDev Eclipse IDE for Python

4 – Aceite a licença e clique em Finish:

Licença

Licença

5 – Aguarde o andamento da instalação:

Andamento

Andamento

6 – Será preciso confiar no certificado da empresa detentora do PyDev a BrainWy Software, clique no certificado da empresa e clique em OK:

Certificado Brainwy Software

Certificado Brainwy Software

7 – Após a instalação completa, você precisa abrir a perspectiva Python para a IDE Eclipse, este é um conceito do Eclipse, cada perspectiva permite que você tenha uma interface gráfica diferente, exemplo, Java, Java EE, C++ e a que nos interessa neste momento a interface para o Python, para abrir clique no ícone na barra de tarefas do lado superior direito ou no menu Windows->Open Perspective->Other e escolha PyDev:

PyDev - Perspective

PyDev – Perspective

8 – Com a perspectiva PyDev Aberta, clique em File->New->Project, escolha a pasta PyDev e expanda e você verá os tipos de projetos que você pode utilizar, eles são Django, Google App Engine e PyDev, escolha PyDev Project, nomeie seu projeto de HelloPyDev:

PyDev Project

PyDev Project

9 – Agora você precisa configurar o interpretador Python, visto que muitos tipos de projetos como o Google App Engine suportam apenas a versão 2.7 do Python. Clique em Please Configure an Interpreter Before Proceeding e clique em Quick-Auto Config. Selecione a opção Add Project Diretory to the PythonPath e clique em Finish:

Configurar Interpretador Python

Configurar Interpretador Python

10 – Com o projeto PyDev criado, clique com o botão direito do mouse em cima do seu projeto na janela PyDev Package Explorer, escolha New  e escolha PyDev Module, nomeie o pacote como DevAberto e modulo de hello e clique em Finish:

Modulo Python

Modulo Python

11 – Abra o arquivo hello.py, copie e cole o código abaixo no seu arquivo vazio:

Código Python

Código Python

12 – Clique em Run na barra de tarefas (seta verde), na janela Run As escolha Python Run:

Python Run

Python Run

13 – Pronto! Você criou o seu primeiro programa Python utilizando o PyDev na IDE Eclipse:

Programa - Python - Tkinter

Programa – Python – Tkinter

Exemplo:

Neste exemplo criamos um simples programa Python chamado Hello World utilizando a GUI Tkinter.

Python

#!/usr/bin/env python
# -*- coding: latin-1 -*-
# Desenvolvimento Aberto
# hello.py

'''
Created on 21/09/2014

@author: Desenvolvimento Aberto
'''
# importa modulo
from Tkinter import *

# Cria classe hello
class hello(Frame):

    # Construtor da classe
    def __init__(self, formulario=None):
        Frame.__init__(self, formulario)
        # Cria texto
        texto = "PyDev - Python IDE for Eclipse - Linux" + \
                "\n\n\n\nDesenvolvimento Aberto\n\nHello World\n\nTkinter!!!!"               

        # Cria um novo label
        rotulo = Label(self, text = texto)

        # Retira espaço desocupado na janela
        rotulo.pack(padx=70, pady=30)
        self.pack()

# Cria aplicação
root = Tk(className="..::Desenvolvimento Aberto::.. - Linux")
app = hello(formulario=root)
app.mainloop()

Instalando o Eclipse Luna – C++ – Linux

Publicado: 21 de setembro de 2014 em C/C++

O Eclipse é sem duvida um dos mais famosos ambiente de desenvolvimento integrado (IDE) para Java, mas a IDE Eclipse suporta também as linguagens de programação C/C++ PHP. Você pode facilmente combinar o suporte ao idioma e outras características utilizando qualquer um dos pacotes padrões, você pode também utilizar inúmeras extensões permitindo a personalização praticamente ilimitada da IDE Eclipse.

Entretanto a IDE Eclipse é um ambiente profissional e sua versão para C++, pode não ser tão amigável para os iniciantes assim como outras IDEs disponíveis para a linguagem. Para instalar o Eclipse no Linux você precisa descompactar o arquivo baixado corretamente, pois uma descompactação sem os parâmetros necessários podem bloquear a exibição do menu principal da IDE no Ubuntu (experimente baixar e descompactar com o gerenciador de arquivos pela GUI), a linha de comando correta para descompactação é como a do exemplo abaixo:


tar xzvf eclipse-cpp-luna-R-linux-gtk-x86_64.tar.gz

Download Eclipse: https://www.eclipse.org/ide/

C/C++ e o Eclipse

A IDE Eclipse pode ser facilmente instalada no Linux, pois o sistema operacional já comtempla um compilador C/C++, chamado GNU GCC Compiler (GCC ++). Utilizar o C/C++ no sistema operacional Linux é relativamente fácil, a única diferença inicial no qual você precisa saber é que um código fonte C/C++ para Linux precisa ser construído (Build) antes de ser compilado. A construção do seu aplicativo C/C++ também pode ser limpa (Clean) ou seja você pode excluir toda a construção do aplicativo (Build) e criar uma nova construção quando for necessário. Outro ponto importante que você precisa saber são os diretórios onde o Linux utiliza seus includes, caso precise adicionar uma nova biblioteca de arquivos Headers, os diretórios são: /usr/include.

O Eclipse não executará o build e clean automaticamente para você, é preciso fazer tudo manualmente, você precisa ter cuidado ao utilizar as configurações do Eclipse ou você pode inutiliza-lo criando erros na construção ou compilação dos seu aplicativos, mas não preocupe você pode restaurar as configurações efetuando uma limpeza, utilizando as opções Build All ou Clean All na opção Build Configuration no menu de contexto do seu projeto (botão direito no nome do projeto) ou pode construir e limpar o seu projeto usando a opção Build Project ou Clean Project.

Instalando o Eclipse

1 – Após efetuar o download e descompactação dos arquivos, clique no executável Eclipse (requer Java), caso ainda não tenha instalado o Java:

sudo add-apt-repository ppa:webupd8team/java
sudo apt-get update
sudo apt-get install oracle-java7-installer
Eclipse - Bem-vindo

Eclipse – Bem-vindo

2 – Feche a janela Welcome e no menu File clique em New e escolha C++ Project, na janela subsequente em Project Name, preencha com Hello, e na opção Toolchains escolha Linux GCC:

Novo Projeto

Novo Projeto

3 – Na janela Project Explorer, clique em cima do seu projeto com o botão direito e escolha New e em seguida escolha Source File. Em Source File preencha com hello.cpp:

Source File

Source File

4 – Copie e cole o código abaixo no seu arquivo vazio, clique com o botão direito do mouse em seu projeto e escolha a opção Build Project:

Build

Build

5  – Após a construção do seu projeto ser efetuada com sucesso, você pode perceber que o Eclipse criou uma nova pasta na sua arvore do projeto chamada Binaries, ela contem o seu arquivo executável que terá o nome do seu projeto. Agora você pode compilar o seu projeto clicando em Run na barra de ferramentas (seta verde):

Console

Console

Pronto! Seu programa foi compilado com sucesso e exibido em uma janela de console do Eclipse. Agora você esta apto a utilizar os projetos C/C++ para console encontrados na categoria C++, exceto os projetos visuais utilizando as classes MFC que são exclusivos para Windows, os projetos visuais para C++ de outras plataformas ainda serão publicados.

Como aprender C++ neste site?

Após instalar o Code blocks ou Eclipse, no menu categorias clique em C/C++ e vá para o primeiro post, cada post contem uma teoria e um código fonte, siga os em ordem decrescente ou seja do ultimo para o mais recente, o post mais antigo contem as primeiras lições e como usar a IDE, continue acompanhando o site para se atualizar e aprender mais sobre C++.

Exemplo:

Este é um programa básico conhecido como Hello Word.

C++

/*
 * hello.cpp
 *
 *  Created on: 21/09/2014
 *      Author: Desenvolvimento Aberto
 */

#include <iostream>

using namespace std;

int main()
{
    cout << "Hello world!" << endl;
    return 0;
}

Instalando o Code Blocks – C/C++ – Linux

Publicado: 21 de setembro de 2014 em C/C++

Code::Blocks é um software livre e de código aberto, multi-plataforma para as linguagens C, C ++, e Fortran. É uma IDE construída para atender as mais exigentes necessidades de seus usuários. Ela é projetada para ser muito extensível e totalmente configurável, uma IDE com todos os recursos que você precisa, com uma aparência consistente e um look and feel que facilita sua operação em várias plataformas. Construído em torno de um framework de plug-ins, o Code::Blocks pode ser estendido facilmente através de um novo plug-in. Qualquer tipo de funcionalidade pode ser adicionada pela instalação/codificação de um plug-in.

Code::Blocks: http://www.codeblocks.org/

C/C++ e o Code::Blocks

A IDE Code::Blocks pode ser facilmente instalada no Linux, pois o sistema operacional já comtempla um compilador C/C++, chamado GNU GCC Compiler. Utilizar o C/C++ no sistema operacional Linux é relativamente fácil, a única diferença inicial no qual você precisa saber é que um código fonte C/C++ para Linux precisa ser construído (Build) antes de ser compilado, mas não se preocupe o Code::Blocks irá lhe avisar quando a construção for necessária. A construção do seu aplicativo C/C++ também pode ser limpa (Clean) ou seja você pode excluir toda a construção do aplicativo (Build) e criar uma nova construção quando for necessário.

Outro ponto importante que você precisa saber são os diretórios onde o Linux utiliza seus includes, caso precise adicionar uma nova biblioteca de arquivos Headers, os diretórios são: /usr/include.

Instalando o Code::Blocks

1 – Você pode instalar o C::B de um modo bem simples, basta utilizar a instrução abaixo em uma janela do terminal, após a instalação abra a IDE, digitando seu nome (codeblocks), e na janela de boas vindas clique em novo projeto:


sudo apt-get install codeblocks libwxgtk2.8-dev

Welcome - Novo Projeto

Welcome – Novo Projeto

2- Em Category, escolha a opção Console e clique em GO:

Projeto para o Console

Projeto para o Console

3 – Na janela Console Application escolha C++ para sua aplicação e clique em Next:

C++ Application

C++ Application

4 – Escolha um titulo e um local para salvar seu projeto e clique em Next:

Titulo e Diretório

Titulo e Diretório

5 –  Escolha o compilador C/C++ de sua preferencia ou utilize o padrão e clique em Finish:

Compilador

Compilador

6 – Um código de um programa Hello Word será automaticamente criado para você, altere como desejar ou clique em Run. A IDE irá lhe perguntar se deseja construir o seu projeto, clique em Yes:

Construindo - Project Build

Construindo – Project Build

7 – Pronto! Seu programa foi compilado com sucesso e exibido em uma janela de console do Xterm.

Console

Console

Agora você esta apto a utilizar os projetos C/C++ para console encontrados na categoria C++, exceto os projetos visuais utilizando as classes MFC que são exclusivos para Windows, os projetos visuais para C++ de outras plataformas ainda serão publicados.

Como aprender C++ neste site?

Após instalar o Code blocks ou Eclipse, no menu categorias clique em C/C++ e vá para o primeiro post, cada post contem uma teoria e um código fonte, siga os em ordem decrescente ou seja do ultimo para o mais recente, o post mais antigo contem as primeiras lições e como usar a IDE, continue acompanhando o site para se atualizar e aprender mais sobre C++.