Arquivo da categoria ‘Python’

Django – ORM – Queries – MySQL – Python

Publicado: 8 de janeiro de 2015 em Python

Depois de criar os seus modelos de dados, o Django lhe fornece automaticamente uma API de banco de dados com abstração que permite criar, recuperar, atualizar e excluir objetos. Você pode utilizar uma gama de instruções Python para manipular dados através de objetos fornecidos pelo ORM Django que também lhe proporciona praticidade e segurança pois sua arquitetura foi construída sob as boas praticas de acesso a dados, onde o desenvolvedor não precisa saber de detalhes técnicos sobre os diferentes bancos de dados pois os objetos já incluem recursos para minimizar o acesso ao banco de dados, criação de IDs automáticos e muitas outras vantagens.

Django Queries: https://docs.djangoproject.com/en/1.7/topics/db/queries/

Usando o Django ORM

1 – Em um diretório de sua escolha crie um projeto e uma aplicação Django:

Django - Projeto e Aplicação

Django – Projeto e Aplicação

2 – No arquivo settings.py do seu projeto, plugue sua aplicação:

Django - Plugar Aplicação

Django – Plugar Aplicação

3 – Defina as configurações para o acesso ao banco de dados MySQL:

Django - MySQL

Django – MySQL

4 – Abra o arquivo de modelo de sua aplicação e escreva seu modelo:

Django - Modelo

Django – Modelo

5 – Valide, gere o SQL e sincronize o bando de dados:

Django - Sincronizar Modelo

Django – Sincronizar Modelo

6 – Agora vamos utilizar o Shell do Django para testar sua API para o banco de dados, vamos utilizar as operações básicas conhecidas com CRUD.

Vamos tomar como exemplo que a Camila goste da banda chamada Stone Temple Pilots, o modelo proporciona que o usuário escolha sua musica e seu álbum preferido:

Django - Crud - Criar e Ler

Django – CRUD – Criar e Ler – Dados

7 – Também podemos recuperar os dados e altera-los caso a Camila tenha lembrado uma musica que goste mais e deseje alterar seu registro:

Django - CRUD - Alterar - Dados

Django – CRUD – Alterar – Dados

8 – Se a Camila desejar excluir seu registro:

Django - CRUD - Deletar - Dados

Django – CRUD – Deletar – Dados

Exemplo:

Neste exemplo criamos um projeto e uma aplicação Django e criamos um modelo de dados através de seu ORM e o utilizamos para efetuar operações CRUD através do seu Shell.

Python

Modelo

from django.db import models

# Desenvolvimento Aberto - Model

class MeuModelo(models.Model):
    nome   = models.CharField(max_length=50)
    album  = models.CharField(max_length=50)
    musica = models.CharField(max_length=70)

Shell – Manipulando objetos ORM

# Importa modelo
from minhaapp.models import MeuModelo

# Inserir e Retornar dados
M1 = MeuModelo(nome="Camila", album="Core", musica="plush")
M1.save()

# Verifica dados do objeto
MeuModelo.objects.values_list(flat=True)

# Alterar
altera = MeuModelo.objects.get(id=1)
altera.musica ="Interstate Love Song"
altera.album="Purple"
altera.save()

MeuModelo.objects.values_list(flat=True)

# Deletar

apagar = MeuModelo.objects.get(id=1)
apagar.delete()

MeuModelo.objects.values_list(flat=True)

Django – Model e View – MySQL – Python

Publicado: 6 de janeiro de 2015 em Python

Um modelo é a única e definitiva fonte de informações sobre seus dados. Ele contém os campos essenciais e os comportamentos dos dados que você está armazenando. Geralmente, cada modelo mapeia uma tabela do banco de dados. Como uma regra em geral, cada modelo é uma classe em Python e cada atributo do modelo representa um campo no banco de dados.

Em Django, a maioria das interações com um banco de dados são feitas por meio de seu ORM (Object-Relational Mapper), que é um recurso de ações do Django bem parecido com outros frameworks como o famoso Rails. Os quadros ORMs são cada vez mais populares entre os desenvolvedores, pois eles automatizam muitas interações comuns com um banco de dados e usam abordagens orientadas a objetos familiares em vez de instruções SQL. Contudo desenvolvedores podem optar por um não utilizar o ORM nativo do Django o substituindo por um Toolkit como o SQLAlchemy que é um kit de ferramentas Python SQL e Object Relational Mapper que dá aos desenvolvedores de aplicativos o poder e a flexibilidade do SQL.

Django Models: https://docs.djangoproject.com/en/1.7/topics/db/models/

Criando um Modelo e Exibindo seus Dados

Vamos começar criando um modelo básico para uma tabela do banco de dados igual a uma tabela no qual já utilizamos em outros exemplos e criamos usando scripts SQL. No entanto não podemos utilizar a tabela já pronta pois vamos cria-la através do ORM do Django sem utilizar instruções SQL.

Ao criar seus modelos o Django cria uma serie de outras tabelas no banco de dados que são necessárias para que um projeto funcione corretamente, não se preocupe com isto agora, o universo de frameworks ORMs são profundos e possuem seus próprios conceitos nos quais são capazes de facilitar a vida do desenvolvedor proporcionando uma sintaxe uniforme e regras sobre as boas praticas de utilização para se manipular dados, evitando assim que desenvolvedores utilizem o banco de dados de forma despadronizada, deste modo, garantindo de um jeito mais eficaz sua normalização e seu desempenho.

1 – Crie um projeto e uma aplicação Django, vamos utilizar o projeto e a aplicação criada anteriormente chamada HelloWorldApp, e vamos utilizar o conector Python para MySQL da Oracle, que você também encontra no post anterior. Para utilizar o conector, altere o arquivo settings.py do seu projeto e defina a conexão e seus parâmetros:

MySQL - settings.py

MySQL – settings.py

2 – Abra o arquivo models.py e crie seu modelo, utilizando o código abaixo:

Model

Model

3 – Abra o terminal do Linux, pois precisamos utilizar alguns comandos do administrador Django para efetuar as tarefas necessárias, elas são: A validação do modelo, a criação do script SQL para o modelo, e a execução do script SQL no banco de dados. Utilize os comandos abaixo:

python manage.py validate

python manage.py sqlall HelloWorldApp

python manage.py syncdb
Django - Validate - Sqlall, SyncDB

Django – Validate – Sqlall, SyncDB

4 – Através do ORM do Django, uma vez que você tem um modelo e sua respectiva tabela no banco de dados, você pode utilizar comandos para operações CRUD (ler, criar, alterar e deletar). Use o comando abaixo para criar um objeto do modelo e inserir dados no banco:

python manage.py shell

from HelloWorldApp.models import Funcionario

f1 = Funcionario(nome="James", sobrenome="Hetfield", cargo="Vocalista/Guitarrista", salario = "1234.56")
f1.save()
Python Shell

Python Shell

5 – Você pode abrir o MySQL Workbench para visualizar sua tabela e as tabelas que o ORM do Django criou assim que você definiu seu primeiro modelo:

MySQL Workbench

MySQL Workbench

6 – Modifique seu arquivo views.py de acordo com o código correspondente e rode o servidor Django e teste sua aplicação:

Django - Aplicação

Django – Aplicação

Exemplo:

Neste exemplo criamos uma aplicação simples que utiliza o banco de dados MySQL, criando um modelo de dados e o exibindo através de sua visão.

Python

settings.py

"""
Django settings for devaberto project.

For more information on this file, see
https://docs.djangoproject.com/en/1.6/topics/settings/

For the full list of settings and their values, see
https://docs.djangoproject.com/en/1.6/ref/settings/
"""

# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
import os
BASE_DIR = os.path.dirname(os.path.dirname(__file__))

# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/1.6/howto/deployment/checklist/

# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = 's8eic)^+f@%gg0ffq9j3_kfsoo11k*a-&8x7jw@2p(ujy$=p4a'

# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True

TEMPLATE_DEBUG = True

ALLOWED_HOSTS = []

# Application definition

INSTALLED_APPS = (
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'HelloWorldApp',    

)

MIDDLEWARE_CLASSES = (
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
)

ROOT_URLCONF = 'devaberto.urls'

WSGI_APPLICATION = 'devaberto.wsgi.application'

# Database
# https://docs.djangoproject.com/en/1.6/ref/settings/#databases

DATABASES = {
    'default': {
        'NAME': 'DAsandbox',
        'ENGINE': 'mysql.connector.django',
        'USER': 'root',
        'PASSWORD': 'pass',
        'OPTIONS': {
          'autocommit': True,
        },
    }
}

# Internationalization
# https://docs.djangoproject.com/en/1.6/topics/i18n/

LANGUAGE_CODE = 'en-us'

TIME_ZONE = 'UTC'

USE_I18N = True

USE_L10N = True

USE_TZ = True

# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/1.6/howto/static-files/

STATIC_URL = '/static/'

models.py

from django.db import models

# Create your models here.

class Funcionario (models.Model):
    nome = models.CharField(max_length=30)
    sobrenome = models.CharField(max_length=50)
    cargo = models.CharField(max_length=50)
    salario = models.DecimalField(max_digits=19, decimal_places=10)

views.py

# coding=utf-8
from django.shortcuts import render
from django.http import HttpResponse

# Importa dados
from HelloWorldApp.models import Funcionario

# Retorna dados atraves do objeto do modelo
dados = Funcionario.objects.values_list(flat=True)

# Recupera campos de uma row
cod = str(dados[0][0])
nome = str(dados[0][1])
sobrenome = str(dados[0][2])
cargo = str(dados[0][3])
salario =str(dados[0][4])

# Cria simples HTML
html = """
 <h1>Desenvolvimento Aberto</h1>
<h2>Django - Models e Views</h2>
<br>
<h3>MySQL - Dados:</h3>
"""

# Formataçao simples
row =  cod + " - " + nome + " " + sobrenome + \
       " - " + cargo + " - R$: " + salario

# Exibe View
def hello(request):
    return HttpResponse(html + row)

O MySQL Community Edition é uma versão gratuita do banco de dados de código aberto mais popular do mundo, que é apoiado por uma comunidade ativa de desenvolvedores de código aberto e entusiastas. O MySQL hoje suporta Unicode, Full Text Indexes, replicação, Hot Backup, GIS, OLAP e muitos outros recursos de banco de dados.

O MySQL Workbench fornece aos DBAs e desenvolvedores um ambiente integrado de ferramentas para, design e modelagem do banco de dados, desenvolvimento SQL, administração do banco de dados e migração. O MySQL Workbench necessita de bibliotecas adicionais para que funcione corretamente, deste modo consulte o site oficial caso queira instalar em um sistema operacional diferente do Linux.

MySQL Community Edition: http://www.mysql.com/

O MySQL Connector/Python habilita programas escritos em Python acessar o bancos de dados MySQL, usando uma API que é compatível com o Python Database API Specification v2.0 (PEP 249). O conector é escrito em Python puro e não tem quaisquer dependências, exceto a biblioteca padrão do Python.

MySQL Connector/Python: http://dev.mysql.com/downloads/connector/python

Instalando e Testando o MySQL e o Python Connector

1- Primeiro você precisa baixar o MySQL Connector/Python do site acima em uma pasta de sua escolha, é necessário um login no site da Oracle, crie um perfil gratuito caso ainda não tenha um. Para instalar o banco de dados MySQL, a ferramenta de administração digite os comandos abaixo no terminal do Linux. Quando questionado escolha uma senha para o usuário root:

sudo apt-get install mysql-server

sudo apt-get install mysql-workbench

sudo apt-get install libmysqlclient-dev
MySQL Community Edition

MySQL Community Edition

2 – Após a instalação das três aplicações digite no terminal mysql-workbench para abrir a ferramenta de administração e desenvolvimento do MySQL:

MySQL Workbench

MySQL Workbench

3 – Clique no quadro Local Instance e digite a senha para o usuário root para se conectar, rode as instruções SQL abaixo para criar um banco de dados e uma tabela para testes:

Workbench - SQL

Workbench – SQL

4 – De volta ao terminal do Linux, instale o conector Python baixado anteriormente utilizando o seguinte comando:

sudo dpkg -i mysql-connector-python_2.0.2-1ubuntu14.04_all.deb
Pacote Debian - Oracle Connector/Python

Pacote Debian – Oracle Connector/Python

5 – Abra a IDE ou o editor e de sua preferencia e utilize o código abaixo para testar o conector:

PyCharm Community - Python

PyCharm Community – Python

Exemplo:

Neste exemplo instalamos o banco de dados MySQL, sua ferramenta de desenvolvimento e administração e as bibliotecas necessária para que o Workbench funcione corretamente, ainda instalamos e testamos o MySQL Connector Python da Oracle.

SQL

-- Cria banco de dados
Create database DAsandbox;
 
-- Cria privilegios para o usuário root
Grant all privileges on DAsandbox.*
to 'root'@'localhost' identified by 'password';
 
-- nivela privilegios
FLUSH PRIVILEGES;

-- Usa database
use DAsandbox;

-- Cria tabela
Create table Teste ( 
  id int, 
  nome varchar(50),
  sobrenome varchar(70),
  cargo varchar(30),
  salario decimal(9,2));

-- Insere dados na tabela
insert into Teste values (1, 'John','Lennon',
      'Guitarrista/Vocalista', 1234.56);

-- Testa tabela
select * from Teste;

Python

__author__ = 'Desenvolvimento Aberto'

# Importa modulos
import mysql.connector

# Cria conexao
conn = mysql.connector.connect(user='root', password='*******',
                              host='127.0.0.1',
                              database='DAsandbox')
# Abre cursor
cursor = conn.cursor()

# Define pesquisa
query = ("SELECT * FROM Teste ")

# Executa pesquisa
cursor.execute(query)

# Imprime resultado
for (id, nome, sobrenome, cargo, salario) in cursor:
  print("{}, {}, {}, {}, {}".format(
    id, nome, sobrenome, cargo, salario))

# Fecha cursor e conexao
cursor.close()
conn.close()

O Django é um framework Web para Python de alto nível que incentiva o desenvolvimento rápido e um design clean e pragmático. Criado por desenvolvedores experientes, ele cuida de grande parte do trabalho de desenvolvimento Web, para que você possa se concentrar em escrever seu aplicativo sem a necessidade de reinventar a roda. Django é um framework livre e open source.

Existem outros frameworks ótimos para Python direcionados ao desenvolvimento Web, como o Web2py, no entanto o Django é o mais famoso e o mais requisitado no mercado de trabalho atual, podemos dizer que o Django em termos de popularidade se assemelha ao framework Rails para Ruby mas conceitualmente possui diferenças significativas, Rails utiliza o Pattern MVC enquanto o Django utiliza o conceito MVT (Model View Template).

Django: https://www.djangoproject.com/

Instalando o Django e Criando Uma Aplicação Web

O Django é fácil de instalar e simples de utilizar, pode ser utilizado pela linha de comando de um modo parecido com o Rails, ou através de IDEs que permitem integração com o Django como, o Eclipse com PyDev (licença gratuita), Visual Studio com Python Tools (versão comunitária gratuita) ou PyCharm Pro (licença com custo).  Neste site você encontra um walkthrough sobre como instalar cada IDE citada. Não se preocupe em entender os conceitos MVT agora, veremos muito sobre o assunto durante o decorrer dos post sobre o Django.

1 – Para instalar o Django digite as instruções abaixo no terminal do Linux:

sudo apt-get install python-django

# Para testar
Python
import django
django.VERSION
Instalar Django - Versão

Instalar Django – Versão

2 – Entre em uma pasta de sua escolha para criar seu primeiro projeto e testa-lo,  digite:

django-admin startproject devaberto
python manage.py runserver
Projeto - Servidor

Django – Projeto – Servidor

3 – Com servidor rodando abra seu navegador e digite o endereço local e a porta 8000:

Testando Servidor

Django – Testando Servidor

4 – Agora que já temos um projeto criado, precisamos criar uma nova aplicação, digite:

django-admin startapp HelloWorldApp
Django - Cria Aplicação

Django – Cria Aplicação

5 – Com o projeto e a aplicação criados, basicamente precisamos alterar dois arquivos do projeto e um arquivo da aplicação. Vamos começar com o arquivo do projeto settings.py onde adicionaremos nossa aplicação:

Django - Settings.py

Django – Settings.py

6 – O arquivo do projeto url.py é onde importaremos nossa View e mapearemos a URL desejada para a nossa View:

Django - URL - View

Django – URL – View

7 – No arquivo da aplicação views.py é onde criaremos o código Python para executar a View. O código HTML deste programa foi retirado do site W3Schools, recomendamos que você o utilize para aprender mais sobre HTML e outras linguagens de script para web, você encontra o link para o site no menu Uteis:

Django - View

Django – View

8 – Com o servidor Django do seu projeto rodando, digite o nome da sua aplicação na url do navegador:

Django - Aplicação

Django – Aplicação – Hello World

Exemplo:

Neste exemplo instalamos o Django e criamos um projeto e uma aplicação básica, onde configuramos os arquivos necessários para que o projeto consiga enxergar nossa View e mapear sua URL, logo criamos uma View para ser executada no navegador.

Python

settings.py

"""
Django settings for devaberto project.

For more information on this file, see
https://docs.djangoproject.com/en/1.6/topics/settings/

For the full list of settings and their values, see
https://docs.djangoproject.com/en/1.6/ref/settings/
"""

# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
import os
BASE_DIR = os.path.dirname(os.path.dirname(__file__))

# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/1.6/howto/deployment/checklist/

# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = 's8eic)^+f@%gg0ffq9j3_kfsoo11k*a-&8x7jw@2p(ujy$=p4a'

# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True

TEMPLATE_DEBUG = True

ALLOWED_HOSTS = []

# Application definition

INSTALLED_APPS = (
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'HelloWorldApp',

)

MIDDLEWARE_CLASSES = (
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
)

ROOT_URLCONF = 'devaberto.urls'

WSGI_APPLICATION = 'devaberto.wsgi.application'

# Database
# https://docs.djangoproject.com/en/1.6/ref/settings/#databases

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
    }
}

# Internationalization
# https://docs.djangoproject.com/en/1.6/topics/i18n/

LANGUAGE_CODE = 'en-us'

TIME_ZONE = 'UTC'

USE_I18N = True

USE_L10N = True

USE_TZ = True

# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/1.6/howto/static-files/

STATIC_URL = '/static/'

url.py

from django.conf.urls import patterns, include, url

# Importa View
from HelloWorldApp.views import hello

# from django.contrib import admin
# admin.autodiscover()

urlpatterns = patterns('',
    # Examples:
    # url(r'^$', 'devaberto.views.home', name='home'),
    # url(r'^blog/', include('blog.urls')),

    # url(r'^admin/', include(admin.site.urls)),
    url(r'HelloWorldApp/$', hello),
)

views.py

from django.shortcuts import render
from django.http import HttpResponse

html = """
<!DOCTYPE html>
<html>
<body>
<h1> Hello World - Python - Django </h1>
<div style="position:relative;">  <div style="opacity:0.5;position:absolute;left:50px;top:-30px;width:300px;height:150px;background-color:#40B3DF"></div>  <div style="opacity:0.3;position:absolute;left:120px;top:20px;width:100px;height:170px;background-color:#8AC007"></div>
  <div style="margin-top:30px;width:360px;height:130px;padding:20px;border-radius:10px;border:10px solid #EE872A;font-size:120%;">
	<h1>CSS = Styles and Colors</h1>
	<div style="letter-spacing:12px;font-size:15px;position:relative;left:25px;top:25px;">Manipulate Text</div>
	<div style="color:#40B3DF;letter-spacing:12px;font-size:15px;position:relative;left:25px;top:30px;">Colors,
	<span style="background-color:#B4009E;color:#ffffff;"> Boxes</span></div>
	</div></div>
</body>
</html>
"""

def hello(request):
    return HttpResponse(html)

No ciência da computação, Data Access Object é um padrão para um objeto que fornece uma interface abstrata para algum tipo de banco de dados ou outro mecanismo de persistência e que permite separar regras de negócio das regras de acesso a banco de dados. A vantagem de usar objetos de acesso a dados é a separação simples e rigorosa entre duas partes importantes de uma aplicação que não devem e não podem conhecer quase que nada uma da outra, e que podem evoluir frequentemente e independentemente.

O DAO implementa o mecanismo de acesso necessário para trabalhar com a fonte de dados. A fonte de dados pode ser um armazenamento persistente como um RDBMS, um serviço externo, como uma troca de B2B, um repositório como um banco de dados LDAP, um serviço de negócios acessado via CORBA, Internet Inter-ORB Protocol (IIOP) ou soquetes de baixo nível. O componente de negócio que se baseia no DAO usa a interface mais simples exposta pelo DAO para seus clientes.

DAO e Python

O DAO é um Pattern da Oracle J2EE para Java, entretanto se tornou um padrão muito popular na programação orientada a objeto, pois separa a logica de negocio da logica do banco de dados e consequentemente da interface com o usuário. Apesar das diferenças entre a linguagem orientada a objeto Java e Python o DAO pode ser usado sem problemas com algumas variações e sendo um padrão flexível e intuitivo é bem possível que você já o utilize nos seus códigos orientados a objeto.

DAO - CRUD - Python

DAO – CRUD – Python

DAO Pattern

O DAO é um padrão flexível e não uma regra ele é utilizado em conjunto com Factory Pattern e Broker Pattern (veja Patterns relacionados no link abaixo) por isto é comum você encontrar algumas variações de sua implementação, o padrão possui quatro especificações para que possa ser utilizado corretamente elas são: DataAccessObject, DataSourceObject, BussinesObject e TransferObject.

  1. DataAccessObjecté o objeto principal desse padrão. O Data Access Object abstrai a implementação fundamental de acesso a dados para o Business Objects para permitir acesso transparente à fonte de dados.
  2. DataSourceObjectrepresenta uma implementação da fonte de dados. Uma fonte de dados pode ser uma base de dados tal como um RDBMS, repositório XML, e assim por diante.
  3. BussinesObject – o objeto de negócios representa o dados do cliente. É o objeto que requer acesso à fonte de dados para obter e armazenar dados.
  4. TransferObjectrepresenta um objeto de transferência usado como um suporte de dados. O Data Access Object pode usar um objeto de transferência para retornar dados para o cliente. O Data Access Object também pode receber os dados do cliente em um objeto de transferência para atualizar os dados na fonte de dados.

DAO Pattern: http://www.oracle.com/technetwork/java/dataaccessobject-138824.html

CRUD – DAO

CRUD acrónimo de Create, Read, Update e Delete, utiliza as quatro operações básicas  para criação, consulta, atualização e exclusão de dados.

Através do padrão DAO vamos utilizar as operações CRUD para manipular dados no banco de dados. O DAO é um Pattern J2EE, mas como ele separa as regras de negocio do acesso a dados também podemos utiliza-lo com qualquer tipo de interface, seja pela linha de comando, uma GUI desktop ou aplicações web.

Para usar o DAO você utiliza o Factory Pattern para criar uma abstração para o acesso a dados e uma classe concreta para seu tipo de acesso como por exemplo OracleDAOFactory, DB2DAOFactory e assim por diante. Então você pode criar a interface para seu objeto DAO chamada DAOFuncionario e a partir da interface (Python não possui interfaces)  você pode criar as classes DAO como, DAOFuncionarioOracle, DAOFuncionarioDB2 e utiliza o objeto de transferência para manipular dados.

Neste exemplo não criamos uma classe abstrata utilizando o Pattern Factory Method, cortamos caminho pois utilizamos apenas um objeto DAO para todos os bancos de dados, mas caso deseje criar uma abstração para classes concretas para cada banco de dados siga a especificação oficial do DAO Pattern no link logo acima.

DAO - Python Packages

DAO – Python Packages

Utilize a imagem acima para ver a organização das Packges para cada classe e atente-se aos drivers utilizados para cada banco de dados.

Exemplo:

Neste exemplo usamos o Pattern DAO para criar operações CRUD utilizando uma interface gráfica, como este exemplo não possuí uma tela de login mude o acesso ao banco e usuário e senha diretamente na classe DAConexaoFactory.

O DAO  pode ser utilizado para varias soluções como no exemplo abaixo para enfatizar sua eficiência utilizamos o DAO em uma interface gráfica escrita com Tkinter justamente para mostrar a independência do negocio e acesso a dados.

Este é o terceiro método que disponibilizamos para manipular dados através de um banco de dados, para ver este mesmo programa utilizando SQL direto da aplicação clique aqui.

Pare ver este programa usando objetos no banco de dados como Views e Triggers clique aqui ou procure na busca também por Stored Procedures e cursores.

Ainda veremos outros métodos para manipular dados através de frameworks específicos.

SQL

Oracle

-- Cria tabela de funcionarios
create table Funcionarios(
  ID_Funcionario  NUMBER(5),
  Nome            VARCHAR2(30),
  Sobrenome       VARCHAR2(70),
  Cargo           VARCHAR2(30),
  Salario         NUMBER(9,2));

DB2

-- Cria tabela de funcionarios
create table Funcionarios (
    ID_Funcionario  INTEGER,
    Nome            VARCHAR(30),
    Sobrenome       VARCHAR(70),
    Cargo           VARCHAR(30),
    Salario         NUMERIC(9,2));

MSSQL

-- Cria tabela de funcionarios
create table Funcionarios (
   ID_Funcionario  Int,
   Nome            VARCHAR(30),
   Sobrenome       VARCHAR(70),
   Cargo           VARCHAR(30),
   Salario         Decimal(9,2));

Python

Objeto – Negócio

# coding=utf-8
# Desenvolvimento Aberto
# Funcionario.py

__author__ = 'Desenvolvimento Aberto'

class Funcionario():

    # Define atributos privados
    def __init__(self):
        self.__id = None
        self.__nome = None
        self.__sobrenome = None
        self.__cargo = None
        self.__salario = None

    # Define métodos Getter e Setter
    # Você também pode optar por propriedades
    def getId(self):
        return self.__id

    def setId(self, id):
        self.__id = id

    def getNome(self):
        return self.__nome

    def setNome(self, nome):
        self.__nome = nome

    def getSobrenome(self):
        return self.__sobrenome

    def setSobrenome(self, sobrenome):
        self.__sobrenome = sobrenome

    def getCargo(self):
        return self.__cargo

    def setCargo(self, cargo):
        self.__cargo = cargo

    def getSalario(self):
        return self.__salario

    def setSalario(self, salario):
        self.__salario = salario

Factory Pattern – DAConexaoFactory

# coding=utf-8
# Desenvolvimento Aberto
# DAConexaoFactory.py

__author__ = 'Desenvolvimento Aberto'

# Importa fonte de dados
import cx_Oracle
import ibm_db
import odbc

class DAConexaoFactory():

    # Define atributos privados

    def __init__(self):
        self.__ORACLE = 1
        self.__DB2 = 2
        self.__MSSQL = 3
        self.__erroCon = None
        self.__factory = None
        self.__IBMDriver = None # IBM DB2 driver (ibm_db)

    # Cria Factory para objetos
    def getConexao(self, banco):

        # Define conexão e fonte de dados
        con = None
        self.__factory = banco

        # Cria string de conexão Oracle
        if (banco == self.__ORACLE):
            sconexao = "user/pass@localhost/XE"
            try:
                con = cx_Oracle.connect(sconexao)
            except Exception, e:
                self.__erroCon = str(e)

        # Cria string de conexão IBM DB2
        if (banco == self.__DB2):
            sconexao = "DATABASE=DEVA" + \
                       ";HOSTNAME=localhost;PORT=50000;PROTOCOL=TCPIP;" + \
                       "UID=user;" + \
                       "PWD=pass"
            try:
                self.__IBMDriver = ibm_db
                con = ibm_db.connect(sconexao, "", "")
            except Exception, e:
                self.__erroCon = str(e)

        # Cria string de conexão MSSQL
        if (banco == self.__MSSQL):
            sconexao = "MSSQLSERVER/user/pass"
            try:
                con = odbc.odbc(sconexao)
            except Exception, e:
                self.__erroCon = str(e)

        return con

    # Retorna Erros
    def getErros(self):
        return self.__erroCon

    # Retorna Factory da conexão
    def getFactory(self):
        return self.__factory

    # Retorna Driver da IBM (Oracle e MSSQL possui outro padrão)
    def getIbmDriver(self):
        return self.__IBMDriver

Objeto DAO – FuncionarioDAO

# coding=utf-8
# Desenvolvimento Aberto
# FuncionarioDAO.py

__author__ = 'Desenvolvimento Aberto'

# Importa pacotes DAO
from DesenvolvimentoAberto.Modelo.Funcionario import Funcionario
from DesenvolvimentoAberto.Conexao.DAConexaoFactory import DAConexaoFactory

class FuncionarioDAO():

    # Construtor da classe
    def __init__(self):
        self.__erro = None
        self.__con = None
        self.__factory = None
        self.__IBMDriver = None
        try:
            # Cria Conexão com o Factory Method Pattern
            # Você pode ter uma classe para cada fonte de dados
            # Unimos as três fontes para o exemplo
            conexao = DAConexaoFactory()
            self.__con = conexao.getConexao(3)
            self.__factory = conexao.getFactory()
            self.__IBMDriver = conexao.getIbmDriver()
        except Exception, e:
            self.__erro = str(e)

    # Metodo de Manipulação de dados

    def buscaFuncionario(self, id):

        # Cria instancia do objeto
        funcionario = Funcionario()

        # Define SQL
        sql = "SELECT * FROM FUNCIONARIOS WHERE ID_FUNCIONARIO = " + str(id)

        # Executa SQL
        try:
            if (self.__factory != 2):
                cursor= self.__con.cursor()
                cursor.execute(sql)
                dados = cursor.fetchone()

            else:
                cursor = self.__IBMDriver.exec_immediate(self.__con, sql)
                dados  = self.__IBMDriver.fetch_tuple(cursor)

        except Exception, e:
            self.__erro = str(e)

        # Alimenta objeto
        funcionario.setId(dados[0])
        funcionario.setNome(dados[1])
        funcionario.setSobrenome(dados[2])
        funcionario.setCargo(dados[3])
        funcionario.setSalario(dados[4])

        # Retorna Objeto
        return funcionario

    def insereFuncionario(self, funcionario ):

        # Define SQL
        # Troca decimal é requerido se Oracle/DB2 for ptbr.
        sql = "INSERT INTO FUNCIONARIOS VALUES (" + \
              funcionario.getId() + ", '" + \
              funcionario.getNome() + "', '" + \
              funcionario.getSobrenome() + "', '" + \
              funcionario.getCargo() + "', " + \
              str(funcionario.getSalario()).replace(",",".") + ")"

        # Executa SQL
        try:
             if (self.__factory != 2):
                 cursor=self.__con.cursor()
                 cursor.execute(sql)
                 self.__con.commit()
                 return True
             else:
                 cursor = self.__IBMDriver.exec_immediate(self.__con, sql)
                 return True

        except Exception, e:
            self.__erro = str(e)
            return False

    def alteraFuncionario(self, funcionario):

       #  Define SQL
       sql = "UPDATE FUNCIONARIOS SET " + \
             "ID_FUNCIONARIO = " + funcionario.getId() + ", " + \
             "NOME = '" + funcionario.getNome() + "', " + \
             "SOBRENOME = '" + funcionario.getSobrenome() + "', " + \
             "CARGO = '" + funcionario.getCargo() + "', " + \
             "SALARIO = " + str(funcionario.getSalario()).replace(",",".") + \
             " WHERE ID_FUNCIONARIO = " + funcionario.getId()

       # Executa SQL
       try:
           if (self.__factory != 2):
               cursor=self.__con.cursor()
               cursor.execute(sql)
               self.__con.commit()
               return True
           else:
               cursor = self.__IBMDriver.exec_immediate(self.__con, sql)
               return True

       except Exception, e:
           self.__erro = str(e)
           return False

    def apagarFuncionario(self, funcionario):

        # Define SQL
        sql = "DELETE FROM FUNCIONARIOS WHERE ID_FUNCIONARIO = " + funcionario.getId()

        # Executa SQL
        try:
            if (self.__factory != 2):
                cursor=self.__con.cursor()
                cursor.execute(sql)
                self.__con.commit()
                return True
            else:
                cursor = self.__IBMDriver.exec_immediate(self.__con, sql)
                return True

        except Exception, e:
            self.__erro = str(e)
            return False

    # Retorna Erro
    def getErro(self):
        return self.__erro

GUI – DADaoApp

#!/usr/bin/env python
# coding=utf-8
# Desenvolvimento Aberto
# DADaoApp.py

# importa modulos
from Tkinter import *
from DesenvolvimentoAberto.Modelo.Funcionario import Funcionario
from DesenvolvimentoAberto.Dao.FuncionarioDAO import FuncionarioDAO
import tkMessageBox

class DADaoApp(Frame):

    def __init__(self, formulario=None):

        # Define formulario
        Frame.__init__(self, formulario)

        # Cria Widgets
        self.titulo = Label(formulario, text="DAO - Pattern")
        self.separador1 = Frame(height=2, bd=1, relief=SUNKEN)
        self.separador2 = Frame(height=2, bd=1, relief=SUNKEN)

        # labels
        self.lcodigo = Label(formulario, text="Codigo:")
        self.lpnome = Label(formulario, text="Nome:")
        self.lsnome = Label(formulario, text="Sobrenome:")
        self.lcargo = Label(formulario, text="Cargo:")
        self.lsalario = Label(formulario, text="Salario:")

        # Entry
        self.tcodigo = Entry(formulario, width=20)
        self.tpnome = Entry(formulario, width=50)
        self.tsnome = Entry(formulario, width=45)
        self.tcargo = Entry(formulario, width=35)
        self.tsalario = Entry(formulario, width=30)

        # Pesquisa
        self.lpesquisa = Label(formulario, text="Pesquisa:")
        self.tpesquisa = Entry(formulario)
        self.botao = Button(formulario, text="Pesquisar", command=self.on_Pesquisar)

        # Ações
        self.painel = Frame()
        self.bnovo = Button(self.painel, text="Novo", command=self.on_novo, width=8)
        self.binserir = Button(self.painel, text="Inserir", command=self.on_inserir, width=8)
        self.balterar = Button(self.painel, text="Alterar", command=self.on_alterar, width=8)
        self.bapagar = Button(self.painel, text="Apagar", command=self.on_apagar, width=8)

        # Cria janela para menssagem
        self.janela = Tk()
        self.janela.wm_withdraw()

        # Define Layout
        self.titulo.grid(row=0, sticky=W+E+N+S, pady=20)
        self.separador1.grid(row=1, sticky=W+E+N+S, columnspan=3)

        # Define Layout Dados
        self.lcodigo.grid(row=3, sticky=W, padx=20)
        self.tcodigo.grid(row=3, column=1, pady=5, sticky=W)
        self.lpnome.grid(row=4, sticky=W, padx=20)
        self.tpnome.grid(row=4, column=1, pady=5, sticky=W)
        self.lsnome.grid(row=5, sticky=W, padx=20)
        self.tsnome.grid(row=5, column=1, pady=5, sticky=W)
        self.lcargo.grid(row=6, sticky=W, padx=20)
        self.tcargo.grid(row=6, column=1, pady=5, sticky=W)
        self.lsalario.grid(row=7, sticky=W, padx=20)
        self.tsalario.grid(row=7, column=1, pady=5, sticky=W)

        # Layout pesquisa
        self.lpesquisa.grid(row=2, column=0, pady=20)
        self.tpesquisa.grid(row=2, column=1, pady=20)
        self.botao.grid(row=2, column=2, padx=10, pady=20)

        # Loayout Ações
        self.bnovo.grid(row=1, column=0, pady=10, padx=5)
        self.binserir.grid(row=1, column=1, pady=10, padx=5)
        self.balterar.grid(row=1, column=2, pady=10, padx=5)
        self.bapagar.grid(row=1, column=3, pady=10, padx=5)
        self.separador2.grid(row=9, sticky=W+E, columnspan=3, pady=10)
        self.painel.grid(row=10, sticky=W+E+S, column=1, columnspan=1)

    # Limpa campo
    def limpar(self):
        self.tcodigo.delete(0, END)
        self.tpnome.delete(0, END)
        self.tsnome.delete(0, END)
        self.tcargo.delete(0, END)
        self.tsalario.delete(0, END)

    # Evento do botão
    def on_Pesquisar(self):

        # Cria objetos Modelo e DAO
        funcionario = Funcionario()
        pesquisar = FuncionarioDAO()

        # Executa trasferencia de Objetos
        try:
            funcionario = pesquisar.buscaFuncionario(self.tpesquisa.get())
        except ValueError:
            tkMessageBox.showinfo(title="Erro", message=pesquisar.getErro(), parent=self.janela)

        # Exibe dados
        self.limpar()
        self.tcodigo.insert(0, str(funcionario.getId()))
        self.tpnome.insert(0, funcionario.getNome())
        self.tsnome.insert(0, funcionario.getSobrenome())
        self.tcargo.insert(0, funcionario.getCargo())
        self.tsalario.insert(0, str(funcionario.getSalario()))

    # limpa widgets
    def on_novo(self):
        self.limpar()
        self.tcodigo.focus()

    # Insere dados
    def on_inserir(self):

        # Cria objeto Modelo
        funcionario = Funcionario()

        # Alimenta dados ao objeto
        funcionario.setId(self.tcodigo.get())
        funcionario.setNome(self.tpnome.get())
        funcionario.setSobrenome(self.tsnome.get())
        funcionario.setCargo(self.tcargo.get())
        funcionario.setSalario(self.tsalario.get())

        # Cria objeto DAO
        inserir = FuncionarioDAO()

        # Executa trasferencia de Objetos
        resultado = inserir.insereFuncionario(funcionario)

        # Exibe Resultado
        if (resultado):
            tkMessageBox.showinfo(title="Menssagem", message="Dados inseridos com suscesso!", parent=self.janela)
        else:
            tkMessageBox.showinfo(title="Erro", message=inserir.getErro(), parent=self.janela)

    # Altera dados
    def on_alterar(self):
        # Cria objeto Modelo
        funcionario = Funcionario()

        # Alimenta objeto
        funcionario.setId(self.tcodigo.get())
        funcionario.setNome(self.tpnome.get())
        funcionario.setSobrenome(self.tsnome.get())
        funcionario.setCargo(self.tcargo.get())
        funcionario.setSalario(self.tsalario.get())

        # Cria objeto DAO
        alterar = FuncionarioDAO()

        # # Executa trasferencia de Objetos
        resultado = alterar.alteraFuncionario(funcionario)

        # Exibe resultado
        if (resultado):
            tkMessageBox.showinfo(title="Menssagem", message="Dados alterados com suscesso!", parent=self.janela)
        else:
            tkMessageBox.showinfo(title="Erro", message=alterar.getErro(), parent=self.janela)

    # Exclui dados
    def on_apagar(self):

        # Cria objeto Modelo
        funcionario = Funcionario()

        # Alimenta objeto
        funcionario.setId(self.tcodigo.get())
        funcionario.setNome(self.tpnome.get())
        funcionario.setSobrenome(self.tsnome.get())
        funcionario.setCargo(self.tcargo.get())
        funcionario.setSalario(self.tsalario.get())

        #Cria objeto DAO
        apagar = FuncionarioDAO()

        # Executa trasferencia de Objetos
        resultado = apagar.apagarFuncionario(funcionario)

        # Exibe resultado
        if (resultado):
            tkMessageBox.showinfo(title="Menssagem", message="Dados apagados com suscesso!", parent=self.janela)
            self.limpar()
        else:
            tkMessageBox.showinfo(title="Erro", message=apagar.getErro(), parent=self.janela)

# loop do tcl
root = Tk()
root.title('DA - DAO - Data Access Object')
app = DADaoApp(formulario=root)
app.mainloop()
root.destroy()

 

PyCharm – Testes Unitários – Python

Publicado: 28 de novembro de 2014 em Python

A maioria das metodologias disponíveis para o desenvolvimento de software e gerenciamento de projetos incluem como pratica básica essencial o desenvolvimento e execução de testes unitários para que um projeto de desenvolvimento possa passar para próxima fase.

Uma boa execução de um projeto bem elaborado em diversas metodologias utilizam ambientes e exigem que os testes unitários sejam executados no ambiente de desenvolvimento (DEV) utilizando uma ferramenta para este proposito e reexecutados por consultores  funcionais/testadores, na fase de testes unitários no ambiente real de qualidade (QAS) para que só então possam executar a fase de testes integrados antes de aprovarem e homologarem o software para utilização em um ambiente produtivo (PRD).

O teste unitário executado do ponto de vista do setor de qualidade (QAS) é feito validando todas as partes dos software, incluindo, design intuitivo, usabilidade, teclas de atalho, layouts, grafia, links e etc. É claro que existem algumas diferenças sutis entre metodologias, como um ou outro procedimento ou diferentes nomenclaturas mas no final todas possuem o mesmo proposito, um software de qualidade, livre de erros e dentro do orçamento inicial do projeto. Bem! No mundo real, não importa qual a metodologia escolhida, isto nem sempre é possível.

PyCharm Community IDE

PyCharm é um ambiente profissional de desenvolvimento integrado (IDE) utilizado para a programação em Python. Ele fornece uma análise de código, depurador gráfico, testador unidade integrada, integração VCS/DVCS e apoia o desenvolvimento web com Django. Muitos desenvolvedores da comunidade Python elegeram o PyCharm como a melhor IDE para desenvolvimento Python, a IDE pode ser utilizada na versão comunitária ou na versão paga.

PyCharm: http://www.jetbrains.com/pycharm/

PyUnit – Unit Test Framework

O framework de testes unitários para Python, por vezes referido como PyUnit é uma versão da linguagem Python do JUnit. O JUnit é, por sua vez, uma versão Java do framework de testes Smalltalk, o JUnit é muito conhecido e utilizado no mudo Java também proliferou para outras linguagem de programação como entre outras, para C#.

PyUnit: https://docs.python.org/2/library/unittest.html

Executando Testes Unitários no PyCharm

1 – Crie um novo projeto Python chamado DAPyTeste, crie um novo arquivo Python chamado Participante e utilize o código encontrado logo abaixo. Na declaração da classe Participante clique com o botão direito e escolha Go To->Test:

Cria Classe de Teste

Cria Classe de Teste

2 – Para criar o teste escolha apenas os métodos Setters:

Métodos Setters

Métodos Setters

3 – Complete os métodos com respectivo código da classe de teste encontrado logo abaixo, utilize os comentários no código para saber mais sobre os teste unitários.

  • Para efetuar um teste com erros, modifique os valores alimentados nos métodos de teste.
  • Para rodar o teste na barra de ferramentas, selecione Unittests in DAPyTeste e clique em Run:
Erros

Erros

4 – Retorne os valores dos métodos como no código abaixo e execute o teste novamente:

Testes bem sucedidos

Testes bem sucedidos

 

Exemplo:

Neste exemplo criamos uma simples classe com métodos Getter e Setter e uma classe de caso de teste para efetuar um teste unitário nos métodos criados.

Python

Classe – Participante

# coding=utf-8
# Desenvolvimento Aberto
# Participante.py

__author__ = 'Desenvolvimento Aberto'

class Participante():

     # Define atributos privados
     def __init__(self):
         self.__nome = None
         self.__idade = None

     # Define métodos Getter e Setter
     def getNome(self):
         return self.__nome

     def setNome(self, nome):
         self.__nome = nome
         #Inverta o código acima: nome = self.nome
         #Você vai obter um erro de lógica
         #Passara pelo interpretador Python
         #Mas não passara pelo teste Unitário
         #Deste modo você previne erros escritos
         #por desatenção ou desenvolvimento emergências
         #como nos Sprints em algumas metodologias

     def getIdade(self):
         return self.__idade

     def setIdade(self, idade):
         self.__idade = idade

     # Você também pode optar por propriedades
     # Aos métodos Getter e Setter
     # Segue exemplo propriedade Nome:
     @property
     def Nome(self):
         return self.__nome

     @Nome.setter
     def Nome(self, value):
         self.__nome = value

# Cria Instancia da Classe
participante = Participante()

#Alimenta valores
participante.setNome("Joao da Silva")
participante.setIdade(20)

# Imprime dados
print participante.getNome()
print participante.getIdade()

PyUnit Test Case – ParticipanteTeste

# coding=utf-8
# Desenvolvimento Aberto
# TestParticipante.py

from unittest import TestCase
from Participante import Participante

__author__ = 'Desenvolvimento Aberto'

class TestParticipante(TestCase):

    # Define Métodos de Testes

    def test_setNome(self):
        # Testa métodos Getter e Setter
        p1 = Participante()
        p1.setNome("Nome")
        self.assertEqual("Nome", p1.getNome())

    def test_setIdade(self):
        # Testa métodos Getter e Setter
        p2 = Participante()
        p2.setIdade(20)
        self.assertEqual(20, p2.getIdade())

SAP MaxDB é um banco de dados estratégico criado para rodar em todas as soluções SAP e substituir os bancos de dados Oracle, IBM DB2 e MSSQL Server  tornando as soluções SAP mais acessíveis em termos de custo para clientes de grande e médio porte. O SAP MaxDB foi construído como uma solução open source baseado em MySQL sob a licença GNU GPL, as versão anteriores do MaxDB ainda são mantidas pela comunidade open source mas a SAP não contribui mais com estas versões.

Ao longo dos últimos anos, a tecnologia SAP MaxDB continuou a evoluir com investimentos muito significativos em inovações e essas inovações não são em código aberto. Assim o mais recente produto SAP MaxDB não é open source, entretanto ele é gratuito em sua versão comunitária para uso com aplicações não SAP e possui licença comercial para uso com aplicações SAP.

Com 40 anos de inovação atuando em mais de 130 países e com mais de 100 mil clientes que utilizam soluções SAP, o SAP MaxDB ainda é um banco de dados jovem mas conta com mais de 6.500 clientes em 15.000 instalações mais soluções que utilizam liveCache e Content Server.

SAP MaxDB: http://maxdb.sap.com/

SAP MaxDB e Python

O Python é uma poderosa linguagem de scripts que já vem se destacando a algum tempo em aplicações para web e ambiente corporativos, a maior empresa de soluções corporativas não poderia deixar de integrar sua aplicações e utilizar os vários benéficos da linguagem de programação Python e da sua crescente comunidade de desenvolvedores.

A SAP disponibiliza módulos para utilizar o MaxDB com a linguagem de programação Python utilizando os sistemas operacionais Unix, Linux e Windows, possibilitando integrar soluções Enterprise SAP que utilizam o banco de dados MaxDB com aplicações escritas em Python ou permite que aplicações Python utilizem o SAP MaxDB gratuitamente também em soluções que não possuem o intuito de integrar dados com os sistemas SAP.

Wiki Python: Sap MaxDB

IMPORTANTE:  Para utilizar este walkthrough completo integrando uma solução Python com a linguagem de programação ABAP, você precisa instalar vários software entres eles o NetWeaver Application Server ABAP no qual já possui uma instalação completa do ambiente de desenvolvimento SAP com uma instancia do banco de dados MaxDB, caso queira utilizar somente o lado Python você pode baixar o SAP MaxDB diretamente da SAP Store:

NetWeaver Application Server ABAP: Mini SAP

Download SAP MaxDB sistemas não SAP: SAP Store

SAP MaxDB SQL Studio: Desenvolvimento Aberto walkthrough

Módulos Python e Drivers ODBC

A instalação do SAP MaxDB incluída nos produtos SAP como o núcleo de desenvolvimento do sistema SAP R/3 chamado de NetWeaver Application Sever ABAP já comtempla módulos Python para que você possa acessar o banco de dados MaxDB porem a instalação suporta apenas a versão Python 2.3 e se encontra no seguinte local:

C:\sapdb\clients\NSP\lib\python2.3
C:\sapdb\NSP\db\doc\FirstSteps\Python

No entanto o banco de dados possui drivers ODBC para que você se conecte com qualquer versão do Python, você encontra detalhes sobre os módulos Python mais recentes e vários exemplos neste link:

MaxDB Python Modules: SAP Manual Python

Conectando ao MaxDB em instancia SAP com Python

1 – Caso utilize este tutorial com o NetWeaver primeiro tenha certeza que servidor de aplicação e a instancia SAP do banco de dados está rodando, caso utilize apenas o MaxDb e Python ignore este passo:

SAP - Servidor de Aplicação - e Banco de dados - NetWeaver/MaxDB

SAP – Servidor de Aplicação – e Banco de dados – NetWeaver/MaxDB

2 – Abra o SQL Studio utilizando o servidor MaxDB e o banco de dados NSP ou seu próprio banco de dados caso não utilize o sistema SAP:

NSP - NetWeaver Database

NSP – NetWeaver Database

3 – Crie uma tabela Z que significa uma tabela não SAP Standard que não será transparente no conceito do dicionário de dados do sistemas SAP para isto utilize o script logo abaixo, não se assuste para desenvolvedores não SAP isto é apenas uma tabela comum do banco de dados:

Tabela Não Transparente

Tabela Z Não Transparente

4 – Como estamos utilizando uma versão mais recente do Python utilizaremos os drivers ODBC do MaxDB. No painel de controle escolha ferramentas administrativas e fonte de dados ODBC de 64bit, em drivers verifique seu driver NSP:

Driver SAP MaxDB ODBC 64bit

Driver SAP MaxDB ODBC 64bit

5 – Crie uma nova fonte de dados do usuário escolha o driver NSP ou o driver apropriado e clique em concluir:

Fonte de Dados do Usuário

Fonte de Dados do Usuário

6 – Preencha os dados de conexão com o servidor e o banco de dados:

Dados do DNS da conexão

Dados do DNS da conexão

7 – Clique em testar a conexão e alimente o usuário e senha para o banco de dados:

Testar Conexão - Usuário e Senha

Testar Conexão – Usuário e Senha

8 – Com tudo funcionando conclua a conexão:

Conexão OK

Conexão OK

9 – Utilize o código abaixo para manipular dados utilizando o SAP MaxDB:

MaxDB - Programa Python

MaxDB – Programa Python

10 – Para utilizar o ABAP para ler ou gravar dados nesta mesma tabela não transparente utilizando uma Stored Procedure no MaxDB através de códigos Native SQL, utilize o link abaixo para o procedimento ABAP:

Stored Procedure - Abap

Stored Procedure – Abap

Programa SAP – ABAP Native SQL: MaxDB Stored Procedure parâmetros IN e OUT

 Caso conecte em um banco de dados MaxDB utilizando soluções SAP tenha em mente que você deve respeitar o conceito de dados dos sistemas SAP e verificar os termos de garantia de cada produto SAP, visto que este método ao contrario do RFC  ignora a camada de banco de dados SAP e o dicionário de dados ABAP.

Como você pode verificar na imagem acima no ambiente ABAP o valor flutuante não vem formatado por padrão como estão acostumados os desenvolvedores SAP que utilizam instruções Open SQL e o dicionário ABAP no entanto você pode utilizar campos criados no dicionário apenas para a manipulação do valor de saída da Stored Procedure neste caso você deve alinhar os tipos de dados entre as aplicações Python e aplicações ABAP.

Exemplo:

Neste exemplo utilizamos a linguagem de programação Python para se conectar ao banco de dados SAP MaxDB em uma instancia do banco de dados do NetWeaver e integrar uma tabela não transparente que pode ser manipulada tanto do lado Python como dentro do sistema SAP utilizando Native SQL.

SQL – SAP MaxDB

-- Cria tabela no schema SAPNSP
CREATE TABLE SAPNSP.ZFUNCIONARIO
(
            ID_FUNCIONARIO INT,
            NOME VARCHAR (30),
            SOBRENOME VARCHAR(70),
            CARGO VARCHAR(30),
            SALARIO DECIMAL(9,2)
)

-- Insere dados na tabela
Insert into SAPNSP.ZFUNCIONARIO values (1,'Steve','Gates','Programador',2550.56)
Insert into SAPNSP.ZFUNCIONARIO values (2,'Bill','Jobs','Diretor',5143.71)

Python

#!/usr/bin/env python
# -*- coding: cp1252 -*-
# Desenvolvimento Aberto
# MeuSAPMaxDB.py

# importa modulos
from Tkinter import *
import tkMessageBox
import odbc

# Cria formulario
formulario = Tk(className='.::SAP MaxDB - Desenvolvimento Aberto')
formulario.geometry("550x300+300+300")

# Cria janela para menssagem
janela = Tk()
janela.wm_withdraw()

# Cria conexão com o banco de dados
def conectar():
    # Conexão SAPMaxDB
    # SAP MaxDb Drivers necessita que o password seja
    # convertido para letras maisculas (UPPERCASE)
    # Coloque somente caracteres maiusculos no exemplo
    # trate este requerimento no seu codigo fonte
    sconexao =  "SapMaxDB/SAPNSP/password"
    try:
        con = odbc.odbc(sconexao)
    except ValueError:
        tkMessageBox.showinfo(title="Menssagem", message="Erro de Conexão", parent=janela)
    return con

# Executa e retorna cursor
def retornaFuncionarioID(sql, con):
    cursor = con.cursor()
    cursor.execute(sql)
    return cursor

# Evento do botão
def on_Pesquisar():
    # Exibe banco de dados
    titulo['text'] = "Database: SAP MaxDB"

    # Cria conexão
    con = conectar()

    # Define e executa SQL
    sql = "Select * From SAPNSP.ZFUNCIONARIO Where  ID_FUNCIONARIO = " + tpesquisa.get()
    tabela = retornaFuncionarioID(sql, con)

    # Retorna dados
    dados = tabela.fetchone()

    # Exibe dados
    tcodigo.insert(0, str(dados[0]))
    tpnome.insert(0, dados[1])
    tsnome.insert(0, dados[2])
    tcargo.insert(0, dados[3])
    tsalario.insert(0, str(dados[4]))

# Cria componentes widgets
titulo = Label(formulario, text="Database: Nenhum")
separador1 = Frame(height=2, bd=1, relief=SUNKEN)
separador2 = Frame(height=2, bd=1, relief=SUNKEN)

# labels
lcodigo = Label(formulario, text="Codigo:")
lpnome = Label(formulario, text="Nome:")
lsnome = Label(formulario, text="Sobrenome:")
lcargo = Label(formulario, text="Cargo:")
lsalario = Label(formulario, text="Salario:")
# Entry
tcodigo = Entry(formulario)
tpnome = Entry(formulario, width=50)
tsnome = Entry(formulario, width=40)
tcargo = Entry(formulario, width=30)
tsalario = Entry(formulario)
# Pesquisa
lpesquisa = Label(formulario, text="Pesquisa:")
tpesquisa = Entry(formulario)
botao = Button(formulario, text = "Pesquisar", command=on_Pesquisar)

# Define Layout
titulo.grid(row=0, sticky=W+E+N+S, pady=20)
separador1.grid(row=1, sticky=W+E+N+S, pady=5, columnspan=4)
lcodigo.grid(row=2, sticky=W, padx=20)
tcodigo.grid(row=2, column=1, sticky=W, pady=5)
lpnome.grid(row=3, sticky=W, padx=20)
tpnome.grid(row=3, column=1, sticky=W, pady=5)
lsnome.grid(row=4, sticky=W, padx=20)
tsnome.grid(row=4, column=1, sticky=W, pady=5)
lcargo.grid(row=5, sticky=W, padx=20)
tcargo.grid(row=5, column=1, sticky=W, pady=5)
lsalario.grid(row=6, sticky=W, padx=20)
tsalario.grid(row=6, column=1, sticky=W, pady=5)
separador2.grid(row=7,sticky=W+E+N+S, pady=5, columnspan=4)
# Layout pesquisa
lpesquisa.grid(row=8, column=0, pady=20)
tpesquisa.grid(row=8, column=1, pady=20)
botao.grid(row=8, column=2,pady=20)

# loop do tcl
mainloop()

O termo Enterprise se refere a organização empresarial corporativa. Na indústria de computadores, o termo é frequentemente usado para descrever qualquer grande organização que utiliza computadores, sistemas operacionais, softwares ou ferramentas de desenvolvimento para o mundo dos negócios. E ao analisarmos o DNA das soluções Enterprise que encontramos nos dias de hoje, sem duvida encontraremos a herança de uma empresa que foi amplamente responsável por tudo que conhecemos, a IBM, empresa pioneira no desenvolvimento de hardware e softwares corporativos.

O principal software corporativo é chamado de Enterprise Resource Planning (ERP) e grande parte de toda infraestrutura e metodologias existentes no universo corporativo prezam garantir que este software funcione perfeitamente desde o inicio da era da computação empresarial. O ERP nasceu de seu antecessor, Manufacturing Resource Planning (MRP) e evoluiram desde os primórdios dos pacote de gerenciamento de banco de dados comercial desenvolvido por Gene Thomas na IBM na década de 1960. Logo os primeiros sistemas ERP foram concebidos como uma ferramenta organizacional e de programação para as empresas industriais. A função da próxima geração de sistemas de software ERP foram estendidos além dos limites do que poderia ser feito para uso interno de uma empresa de fabricação individual e começou a incluir clientes e fornecedores. Não demorou muito para que outras indústrias reconhecessem os benefícios dos sistemas ERP, então as agências governamentais e organizações do setor de serviços também começaram a tirar proveito desta tecnologia.

A evolução se deu dos processos executados em grandes mainframes, como IBM/360 para os processos atuais que gerenciam enormes quantidades de dados em tempo real e são executados em diferentes plataformas transpondo os limites físicos das empresas, permitindo que o processo de trabalho continue sem fronteiras e a qualquer hora, em qualquer lugar.

De onde vem os softwares Enterprise?

Um rápido passeio pela historia das três maiores soluções Enterprise encontradas no mercado de software da atualidade, nos mostram o como foi o inicio dos sistemas corporativos:

A SAP AG criada em 1972 por cinco consultores da IBM que perceberam a possibilidade de criar um pacote de software padrão a ser executado em um mainframe IBM. Em dezoito meses foi criado o sistema R que foi renomeado para R/1, sendo seguido pelo sistema R/2 de duas camadas e logo depois o R/3 apareceu inicialmente no final dos anos 80 quando a IBM lançou sua arquitetura SNA, mas foi decidido trabalhar com Unix no lugar do mainframe IBM e após cinco anos de desenvolvimento, em 1992 o sistema R/3 finalmente foi lançado.

A JD Edwards World Solution Company, foi fundada em março 1977 e era uma empresa de software empresarial, o foco inicial da empresa foi o desenvolvimento de um programa de contabilidade necessário para seus clientes. Seu produto mais popular chamado World era centralizado em servidores, bem como multiusuário; os usuários poderiam acessar o sistema usando um dos vários terminais de computador da IBM ou “telas verdes”. Como um sistema ERP, o JD Edwards World incluía as três áreas básicas de atuação: analista funcional/negócios, desenvolvedor/programador e  administração do sistema.

O Microsoft Dynamics AX foi originalmente desenvolvido como uma colaboração entre a IBM e a dinamarquesa Damgaard Data que resultou no IBM Axapta. O Axapta foi inicialmente lançado em março de 1998, nos mercados dinamarqueses  e norte-americanos. A IBM devolveu todos os direitos sobre o produto para a Damgaard Data logo após o lançamento da versão 1.5 antes da Damgaard Data ser fundida com Navision Software A/S em 2000, a empresa combinada, inicialmente Navision Damgaard, depois Navision A/S, foi adquirida pela Microsoft em julho de 2002 e em setembro de 2011, a Microsoft anunciou o lançamento da versão nova AX 2012.

Hoje a IBM não possui uma solução de ERP mas ela endossa através de suas alianças poderosas soluções em conjunto com a SAP e Oracle:

IBM ERP Alliance: http://www.ibm.com/solutions/alliance/us/en/index/erp.html

????????????????????????????????????????
O que os Softwares Corporativos Podem Fazer?

Unificar os dados como um todo, integrando os sistemas de gestão empresarial, permitindo a centralização de todo o negócio em uma única fonte, pois são desenvolvidos para atender às necessidades das diferentes áreas de uma empresa.

As varias ferramentas oferecem aos seus gestores um maior controle sobre suas operações e planejamentos, interligando todos os departamentos e se tornando um importante apoio às decisões estratégicas da diretoria, indicando os mercados mais lucrativos no qual pode-se investir.

Como beneficio a empresa passa a obter maior agilidade aos processos e uma maximização de resultados a longo prazo, com a padronização das informações internas consegue-se uma ampla visibilidade dos procedimentos empresariais e uma automação das dinâmicas de apoio. A obtenção de dados em tempo real, possibilita a eliminação das falhas de comunicação entre os setores e um melhor gerenciamento de qualidade de seus produtos ou serviços e também um melhor relacionamento com os seus clientes.

Como é a arquitetura de um software Enterprise?

Os softwares Enterprise geralmente utilizam o topo da tecnologia disponível em termos de hardware. Novos hardwares são construídos para atender as novas exigências que as empresas demandam com o crescimento baseado no beneficio da tecnologia que elas adquirem, sendo assim novos hardwares necessitam de novas versões de softwares e sistemas operacionais para que possam ser controlados, gerando um ciclo de desenvolvimento de tecnologia de ponta.

Os programas Enterprise atuais utilizam uma arquitetura de três camadas, cada camada é auto contida o suficiente de forma que a aplicação pode ser dividida em vários computadores em uma rede distribuída. As camadas são compostas da interface do usuário (Camada de Apresentação ou Servidor de Apresentação); da lógica do negócio (Camada de Negócio ou Servidor de Aplicação) e da camada de banco de dados (Camada de Dados ou Servidor de Dados). Cada camada desta arquitetura é normalmente mantida em um ou mais servidores para tornar-se mais escalonável e independente das demais. Com o mesmo objetivo são utilizadas tecnologias de middleware como, por exemplo, COM, CORBA, Web Services ou RMI. Esta arquitetura tem como características baixos custos de disponibilização, de mudança da base de dados, de mudança na lógica de negócios, eficiente armazenamento e reutilização de recursos.

Três camadas SAP:

R/3 - Três camadas

R/3 – SAP – Três camadas

Três camadas Oracle:

JD Edwards - três camadas

JD Edwards – Oracle – Três camadas

Três camadas Microsoft:

Dynamics - Microsoft - Três camadas

Dynamics – Microsoft – Três camadas

Como funcionam na pratica para desenvolvedores e consultores?

Os softwares corporativos que integram a linha empresarial como já vimos ditam não só a tecnologia de hardware e software mas também o funcionamento de empresas de tecnologia, de desenvolvimento ou consultorias que trabalham com este tipo de solução.

No mercado de softwares corporativos um desenvolvedor em alguns casos também é um tipo de consultor ou especialista, outras profissões que conhecemos no mercado da tecnologia também se enquadram no time de consultores tendo sua própria nomenclatura, os códigos fontes são abertos e podem ser herdados e modificados, porem geralmente tudo que é desenvolvido dentro de um software corporativo pela licença sob o qual ele é gerido é de propriedade da empresa fabricante do software, entretanto é permitindo que consultorias desenvolvam e comercializem módulos adicionais para seus produtos seguindo as melhores praticas de desenvolvimento, implantação e manutenção da empresa detentora da solução.

Os sistemas ERP podem se conectar com qualquer banco de dados topo de linha do mercado e tem como parceiros as empresas fabricantes de cada banco, quando também não é proprietária de uma solução de banco de dados, em ambos os casos os bancos de dados possuem Features exclusivas desenvolvidas para uso com cada um destes sistemas. Os sistemas ERP contam com um dicionário de dados que controla o banco de dados em uso, permitindo que o sistema e os desenvolvedores utilizem uma linguagem única para acesso a dados. Possuem também seu próprio compilador e sua própria linguagem de programação na qual as consultorias podem desenvolver novos módulos ou modificar módulos existentes.

A SAP possui a linguagem Abap, a Oracle utiliza entre outros métodos a linguagem C e a Microsoft a linguagem X++. As empresas terceirizadas também podem desenvolver outros softwares corporativos que se comunicam com o ERP através de um protocolo de comunicação especifico, geralmente utilizando as tecnologias DCOM ou Corba e são nada mais que interfaces para a comunicação entre um sistema proprietário e outro compatível de terceiros através de conexões TCP/IP e podem chamar funções remotas do ERP que são criadas para inserir ou exportar dados garantindo a consistência de dados utilizando a própria regra de negocio do ERP e fornecendo uma maneira para que um programa externo escrito em linguagens como  Java, C, C ++C# ou outras línguas possam também atuar como o cliente ou servidor em uma chamada.

SAP – Abap: Linguagem de programação.

Oracle – JDE: Development Tools.

Microsoft – MorphX: IDE e linguagem X++.

Solutions_key
Como é a Metodologia dos Softwares Enterprise?

Com décadas de experiência no mercado corporativo os softwares empresariais desenvolveram algumas metodologias ao longo dos anos que possibilitam que as empresas utilizem de forma adequada suas soluções, abrangendo todas as fases de um projeto desde a engenharia de software, a definição de escopo, passando pela especificação funcional, design, construção, testes, até chegar à validação, implantação e uso produtivo da solução.

ASAP Methodology: Metodologia ASAP

Oracle Unified Method: Metodologia OUM

Microsoft Dynamics Sure Step methodology: Metodologia MS Sure Step

Falando de modo genérico já que estamos nos referindo a três ótimos softwares empresariais da atualidade, podemos perceber que os três possuem uma arquitetura semelhante que proporciona uma metodologia muito similar para execução de seus projetos, deste modo, segue uma visão geral de um projeto corporativo.

A fase de preparação geralmente é executada por um gerente de projetos e engloba o escopo, estimativas, planejamento inicial do projeto, cronograma, aspectos técnicos, definição de equipe, identificação de riscos e estratégias, planejamento de controle de qualidade e o inicio do projeto.

A fase inicial, já com os recursos definidos em ação, o gerente de projeto e os analistas funcionais devem tratar do levantamento dos processos de negócio, gestão do projeto, mudanças organizacionais, definição dos novos processos de negócio, necessidades e mudanças organizacionais.

Com toda a definição realizada, já na fase de customização e desenvolvimento, entra em cena os consultores especialistas que iniciam a configuração, implementação e o desenvolvimento das definições funcionais que entre elas estão a configuração base, a configuração final, desenvolvimento de programas, implementação de interfaces, testes unitários, testes integrados, documentação de cenários e processos, execução dos treinamentos aos key users e usuários, controle de qualidade e a correção de possíveis erros.

Na fase de pré-produção toda atenção se volta aos detalhes finais como, testes de volume, testes de stress, planejamento da implantação, estratégia de implantação, treinamentos finais e o controle de qualidade.

Com tudo pronto o projeto é finalmente implantado e o sistema é colocado em produção e os retoques finais são a transferência de pré-produção, ajuste da configuração de hardware, ajustes na configuração de software, base de dados, sistema operacional e outros. Só então se inicia os treinamentos finais, suporte aos key-users e usuários e encerramento do projeto.

Ambientes Corporativos

Integrando a metodologia de gestão de projeto os softwares corporativos e suas demais ferramentas são desenvolvidas para utilizar ambientes específicos nos quais tem o intuito de maximizar a eficiência dos métodos de implantação, desenvolvimento, testes, qualidade, treinamento, utilização e gerenciamento dos produtos adquiridos. Cada ambiente possui suas especificações de uso e são utilizados para uma finalidade especifica e devido a eficiência deste modelo outras metodologias também utilizam alguns destes cenários.

Ambientes do SAP:

Alguns dos ambientes SAP

Alguns dos ambientes SAP

Ambientes da Oracle:

Alguns dos ambientes Oracle

Alguns dos ambientes Oracle

Ambientes da Microsoft:

Alguns dos ambientes Microsoft

Alguns dos ambientes Microsoft

Como Desenvolver Suas Próprias Aplicações Enterprise?

As grandes empresas de tecnologia que desenvolvem o hardwaresoftware para o mercado corporativo em sua maioria também desenvolvem ferramentas para desenvolvimento de softwares para empresas terceirizadas, para que estas possam desenvolver seus próprios softwares empresariais ou soluções que complementas as soluções já existentes, entre elas a Oracle, a IBM, a Microsoft e com exceção da SAP que também utilizam em certos casos o Java da Oracle e ferramentas da IBM como a IDE Eclipse. Todas disponibilizam um vasto matérial sobre como desenvolver seus próprios projetos Enterprise, veja os seguintes links:

Microsoft: http://msdn.microsoft.com/en-us/library/ff648951.aspx

Oracle: http://www.oracle.com/technetwork/java/javaee/overview/index.html

IBM: http://www.ibm.com/developerworks/

SAP: Enterprise Learning

O primeiro passo é ter em mente que um software enterprise bem sucedido necessita de hardware adequado, arquitetura e programação adequada, metodologia adequada, consultoria adequada e o mais importante de tudo um grande know-how das regras de negocio das áreas incluídas no escopo de sua solução.

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