Log - tutorial sqlalchemy

#teoria#############################################################################################################################
Jul 10 16:02:25 ||--killown> o que é banco de dados relacional?
Jul 10 16:02:42 ||--nosklo> banco de dados relacional é um tipo de banco de dados que se baseia em relações entre os dados
Jul 10 16:02:51 ||--killown> certo
Jul 10 16:03:36 ||--nosklo> é por isso que o tutorial básico ensina a criar, adicionar dados, buscá-los de volta e modificá-los... e em seguida já vai ensinar relacionamentos
Jul 10 16:03:57 ||--nosklo> mas voltando
Jul 10 16:04:38 ||--nosklo> o ideal seria q a sua classe já fosse útil por si só, e o sqlalchemy iria salvar os dados dela pra vc
Jul 10 16:05:19 ||--nosklo> agora explicando a estrutura do sqlalchemy, igual eu fiz com a do twisted a um tempo atrás
Jul 10 16:05:33 ||--killown> então eu só quero a = Tabela(file,url,lenght)
Jul 10 16:05:39 ||--killown> blz
Jul 10 16:05:44 ||--nosklo> acesso a banco de dados no python é feito através da dbapi 2.0
Jul 10 16:05:57 ||--nosklo> é uma API que os drivers de banco seguem, involve criar connections e cursors
Jul 10 16:06:02 ||--nosklo> cur.execute(), etc
Jul 10 16:06:14 ||--nosklo> o sqlalchemy coloca 3 camadas por cima dessa
Jul 10 16:06:24 ||--nosklo> a primeira camada de mais baixo nível é a conexão
Jul 10 16:06:33 ||--nosklo> no sqlalchemy involve os Engines e Connection Pools
Jul 10 16:06:48 ||--nosklo> um engine representa a forma de conectar a um banco
Jul 10 16:07:02 ||--nosklo> sempre que o sqlalchemy precisa de uma conexão, ele usa o engine para pegar informações sobre como conectar
Jul 10 16:07:17 ||--nosklo> aí a conexão vai pro connection pool, que é um grupo de conexões abertas
Jul 10 16:07:34 ||--nosklo> por padrão ele mantém entre 5 e 10 conexões abertas ao banco, e vai alternando entre elas
Jul 10 16:07:41 ||--nosklo> isso acelera muito o acesso a dados
Jul 10 16:08:10 ||--nosklo> acima desta camada está o sql language expression
Jul 10 16:08:22 ||--nosklo> ele permite vc representar comandos sql com objetos python
Jul 10 16:08:36 ||--killown> certo
Jul 10 16:08:39 ||--nosklo> select(), update(), insert()
Jul 10 16:08:44 ||--nosklo> Table(), Column()
Jul 10 16:09:20 ||--nosklo> vc continua mexendo com SQL, só que fica mais fácil pq vc usa python pra gerar as sentenças sql ao invés de gerar vc mesmo
Jul 10 16:09:55 ||--nosklo> isso facilita principalmente quando a sua sentença sql é gerada, e não fixa -- qdo vc começa a tentar fazer seu programa gerar a sentença certa, as coisas complicam
Jul 10 16:10:05 ||--nosklo> o sqlalchemy acaba com essa complicação
Jul 10 16:10:13 ||--nosklo> vc expressa o que quer em python, e ele traduz pra SQL
Jul 10 16:10:20 ||--killown> uia
Jul 10 16:10:35 ||--nosklo> nessa camada tem um objeto importante
Jul 10 16:10:36 ||--nosklo> o MetaData
Jul 10 16:11:01 ||--nosklo> dentro do objeto metadata, ficam armazenadas as informações sobre as tabelas, campos e índices que existem no banco, e a relação entre eles
Jul 10 16:11:35 ||--nosklo> quando você usa uma função como select(), o sqlalchemy consulta o metadata pra saber quais tabelas devem entrar no FROM , WHERE, JOIN, etc dos comandos SQL gerados
Jul 10 16:12:38 ||--nosklo> por cima dessa camada, foi feita a camada de mais alto nível: o ORM
Jul 10 16:12:45 ||--killown> é obrigatório usar metadata?
Jul 10 16:13:07 ||--nosklo> sim. todo objeto Table ou Column que vc cria tem q estar associado com um metadata
Jul 10 16:13:37 ||--nosklo> mas já com o ORM você já esquece que existe Table, ou qualquer comando SQL
Jul 10 16:13:46 ||--nosklo> o ORM é uma abstração onde você mapeia a sua classe ao banco
Jul 10 16:14:20 ||--nosklo> instâncias da sua classe se tornam registros no banco automaticamente, ao alterar a instância você altera o banco - o sqlalchemy já escreve e executa pra você os comandos sql INSERT, UPDATE, DELETE, etc
Jul 10 16:15:54 ||--killown> e é só gravar essa instância?
Jul 10 16:16:01 ||--nosklo> sim.
Jul 10 16:16:04 ||--killown> eu quero gravar tudo
Jul 10 16:16:15 ||--nosklo> não, você *tem* que definir exatamente o que quer gravar
Jul 10 16:16:16 ||--killown> e carregar essa instância ná próxima vez
Jul 10 16:16:47 ||--nosklo> uma instância tem muito mais coisa do que você vai querer
Jul 10 16:17:03 ||--nosklo> você tem que definir o que é importante na sua instância
Jul 10 16:17:09 ||--killown> dela eu quero self.url self.file_ self.lenght
Jul 10 16:17:16 ||--nosklo> exatamente, foi isso q vc fez
Jul 10 16:17:33 ||--nosklo> assim, ao criar uma instância e adicionar ela na sessão, ela será salva caso a sessão seja commitada
Jul 10 16:17:58 ||--killown> comitar é session.add?
Jul 10 16:18:14 ||--nosklo> comtiar é quando a sua transação acabou de ser feita
Jul 10 16:18:21 ||--nosklo> então você comita a transação para ela se tornar permanente
Jul 10 16:18:24 ||--nosklo> e encerra esta sessão
Jul 10 16:18:36 ||--nosklo> você cria e destrói várias sessões ao curso do seu programa
Jul 10 16:18:50 ||--killown> complicado
Jul 10 16:18:58 ||--nosklo> toda vez que precisar fazer alguma coisa no banco, você cria uma sessão, usa ela para consultar e alterar dados, e depois comita, ou cancela a sessão
Jul 10 16:19:06 ||--nosklo> se vc cancelar, tudo q vc fez naquela sessão "volta atrás"
Jul 10 16:19:13 ||--nosklo> é chamado de rollback()
Jul 10 16:19:29 ||--killown> como comita a sessão?
Jul 10 16:19:35 ||--nosklo> session.commit()
Jul 10 16:19:58 ||--killown> igual no sqlite, so mud ao nome



#Prática#########################################################################################################################

Jul 10 16:20:51 ||--nosklo> então, um exemplo rápido
Jul 10 16:22:17 ||--nosklo> vamos fazer um programa simples que use sqlalchemy pra vc fixar
Jul 10 16:22:23 ||--nosklo> na camada mais alta primeiro, ORM
Jul 10 16:22:32 ||--killown> certo
Jul 10 16:22:41 ||--nosklo> uma agenda de telefones
Jul 10 16:23:07 ||--nosklo> vamos comecar criando o banco
Jul 10 16:23:13 ||--killown> ok
Jul 10 16:32:11 ||--nosklo> killown: hg clone http://bitbucket.org/nosklo/tut_sqlalchemy
Jul 10 16:32:29 ||--killown> 3 arquivos atualizados, 0 arquivos mesclados, 0 arquivos removidos, 0 arquivos não resolvidos
Jul 10 16:32:38 ||--nosklo> cd tut_sqlalchemy
Jul 10 16:32:48 ||--nosklo> python -i test_agenda.py
Jul 10 16:33:04 ||--nosklo> vc vai ver q ele vai criar a tabela Pessoas
Jul 10 16:33:16 ||--nosklo> abra o fonte do test_agenda.py e do bd.py
Jul 10 16:33:20 ||--killown> 2010-07-10 16:33:10,316 INFO sqlalchemy.engine.base.Engine.0x...c58c COMMIT
Jul 10 16:33:58 ||--nosklo> aqui deu mais que isso
Jul 10 16:34:02 ||--nosklo> aqui saiu 2010-07-10 16:34:57,929 INFO sqlalchemy.engine.base.Engine.0x...e30c PRAGMA table_info("pessoas")
Jul 10 16:34:03 ||--nosklo> 2010-07-10 16:34:57,929 INFO sqlalchemy.engine.base.Engine.0x...e30c ()
Jul 10 16:34:03 ||--nosklo> 2010-07-10 16:34:57,930 INFO sqlalchemy.engine.base.Engine.0x...e30c
Jul 10 16:34:03 ||--nosklo> CREATE TABLE pessoas (
Jul 10 16:34:03 ||--nosklo> id INTEGER NOT NULL,
Jul 10 16:34:04 ||--nosklo> nome VARCHAR(100),
Jul 10 16:34:06 ||--nosklo> PRIMARY KEY (id)
Jul 10 16:34:08 ||--nosklo> )
Jul 10 16:34:10 ||--nosklo> 2010-07-10 16:34:57,930 INFO sqlalchemy.engine.base.Engine.0x...e30c ()
Jul 10 16:34:12 ||--nosklo> 2010-07-10 16:34:58,027 INFO sqlalchemy.engine.base.Engine.0x...e30c COMMIT
Jul 10 16:34:22 ||--killown> deu aqui também
Jul 10 16:34:25 ||--nosklo> ah sim.
Jul 10 16:34:25 ||--killown> mas foi pra não flood
Jul 10 16:34:47 ||--killown> tô em db.py
Jul 10 16:34:49 ||--nosklo> certo
Jul 10 16:35:04 ||--nosklo> veja só, eu crio uma classe Pessoa, que é pra representar uma pessoa
Jul 10 16:35:14 ||--nosklo> nessa classe eu defino os atributos que eu acho importantes em uma pessoa
Jul 10 16:35:16 ||--killown> class Pessoa(Base): certo
Jul 10 16:35:17 ||--nosklo> no caso só o nome
Jul 10 16:35:35 ||--nosklo> e um id pra ser a chave, pq pode ter muitas pessoas com mesmo nome
Jul 10 16:35:45 ||--killown> aa tá
Jul 10 16:36:15 ||--nosklo> então, vamos supor que eu crio uma pessoa
Jul 10 16:36:16 ||--killown> você criou a função configure
Jul 10 16:36:23 ||--killown> Base.metadata.bind = engine
Jul 10 16:36:39 ||--killown> Session.configure(bind=engine)
Jul 10 16:36:39 ||--nosklo> essa função vincula o metadata ao engine
Jul 10 16:36:47 ||--nosklo> e tbm o sessionmaker ao engine
Jul 10 16:36:53 ||--killown> certo
Jul 10 16:36:54 ||--nosklo> o sessionmaker é um "fazedor de sessão"
Jul 10 16:37:09 ||--nosklo> então, quando vc rodou com python -i, deu um prompt certo
Jul 10 16:37:23 ||--killown> deu
Jul 10 16:37:33 ||--nosklo> para trabalhar com o banco, é só criar uma sessao
Jul 10 16:37:38 ||--nosklo> s = bd.Session()
Jul 10 16:37:41 ||--killown> Base.metadata.create_all()
Jul 10 16:37:46 ||--killown> pra todos quem?
Jul 10 16:38:02 ||--nosklo> create_all() cria todas as tabelas que ainda não existem, que estão no metadata
Jul 10 16:38:14 ||--nosklo> no caso foi quem criou a tabela "pessoas" no banco
Jul 10 16:38:24 ||--killown> a certo
Jul 10 16:38:25 ||--nosklo> gerou o CREATE TABLE q vc viu
Jul 10 16:38:47 ||--nosklo> s = db.Session()
Jul 10 16:39:02 ||--nosklo> eu chamo o "criador de sessão", ele cria uma sessão
Jul 10 16:39:12 ||--nosklo> >>> s = db.Session()
Jul 10 16:39:13 ||--nosklo> >>> s
Jul 10 16:39:13 ||--nosklo> ||--sqlalchemy.orm.session.Session object at 0xa265c2c>
Jul 10 16:39:29 ||--nosklo> essa sessão eu uso para manipular o banco
Jul 10 16:39:39 ||--nosklo> então, vamos supor que eu crio uma pessoa
Jul 10 16:39:42 ||--nosklo> p = db.Pessoa()
Jul 10 16:39:57 ||--nosklo> p.nome = u'killown'
Jul 10 16:40:17 ||--killown> certo
Jul 10 16:40:18 ||--nosklo> s.add(p)
Jul 10 16:40:23 ||--killown> a minha dúvida fica nesse p
Jul 10 16:40:24 ||--nosklo> adicionei essa pessoa à sessão
Jul 10 16:40:27 ||--killown> como ter ele depois
Jul 10 16:40:30 ||--nosklo> calma
Jul 10 16:41:04 ||--nosklo> veja bem, se eu não adiciono a pessoa à sessão, ela é só um objeto na memória, o sqlalchemy ainda não está gerenciando essa instância
Jul 10 16:41:57 ||--nosklo> neste momento, a sessão está com o objeto já, pendente para salvar no banco se precisar
Jul 10 16:42:00 ||--nosklo> pq eu já adicionei
Jul 10 16:42:05 ||--nosklo> podemos verificar se isso é verdade
Jul 10 16:42:12 ||--nosklo> >>> print s.new
Jul 10 16:42:12 ||--nosklo> IdentitySet([||--telefones.db.Pessoa object at 0xa265bcc>])
Jul 10 16:42:26 ||--nosklo> ou seja, tem um registro novo a ser gravado, na fila de coisas que a sessão tem pra fazer
Jul 10 16:42:59 ||--nosklo> vamos gerar o sql pra salvar essa pessoa no banco
Jul 10 16:43:02 ||--nosklo> s.flush()
Jul 10 16:43:11 ||--nosklo> 2010-07-10 16:44:12,628 INFO sqlalchemy.engine.base.Engine.0x...e30c INSERT INTO pessoas (nome) VALUES (?)
Jul 10 16:43:11 ||--nosklo> 2010-07-10 16:44:12,628 INFO sqlalchemy.engine.base.Engine.0x...e30c (u'killown',)
Jul 10 16:43:42 ||--nosklo> flush() dá descarga na sessão
Jul 10 16:43:49 ||--killown> certo
Jul 10 16:44:00 ||--nosklo> >>> print s.new
Jul 10 16:44:00 ||--nosklo> IdentitySet([])
Jul 10 16:44:04 ||--nosklo> agora não tem mais nada
Jul 10 16:44:17 ||--killown> >>> print s.new
Jul 10 16:44:17 ||--killown> IdentitySet([])
Jul 10 16:44:24 ||--nosklo> repare que a instância q vc tem, *ainda* está vinculada à sessão
Jul 10 16:44:25 ||--killown> tá
Jul 10 16:44:46 ||--nosklo> >>> p.nome = u'José killown'
Jul 10 16:44:47 ||--nosklo> >>> print s.dirty
Jul 10 16:44:47 ||--nosklo> IdentitySet([||--telefones.db.Pessoa object at 0xa265bcc>])
Jul 10 16:45:15 ||--nosklo> ao mudar o nome da instância que eu já tinha, a sessão já detectou e colocou na fila de "registros sujos" ou "modificados"
Jul 10 16:45:31 ||--nosklo> >>> s.flush()
Jul 10 16:45:31 ||--nosklo> 2010-07-10 16:46:34,140 INFO sqlalchemy.engine.base.Engine.0x...e30c UPDATE pessoas SET nome=? WHERE pessoas.id = ?
Jul 10 16:45:31 ||--nosklo> 2010-07-10 16:46:34,141 INFO sqlalchemy.engine.base.Engine.0x...e30c (u'Jos\xe9 killown', 1)
Jul 10 16:45:41 ||--nosklo> ao dar o flush, ele faz a mesma coisa
Jul 10 16:45:49 ||--killown> 2010-07-10 16:45:43,355 INFO sqlalchemy.engine.base.Engine.0x...d58c (u'nosklo manel', 1)
Jul 10 16:46:11 ||--killown> então o flush salva a pessoa no banco
Jul 10 16:46:14 ||--nosklo> só que desta vez ele gerou o comando UPDATE, não INSERT
Jul 10 16:46:25 ||--nosklo> não, o banco ainda está com a transação aberta
Jul 10 16:46:27 ||--killown> a é
Jul 10 16:46:31 ||--killown> usamos nome
Jul 10 16:46:48 ||--killown> ||--nosklo> vamos gerar o sql pra salvar essa pessoa no banco
Jul 10 16:46:48 ||--killown> ||--nosklo> s.flush()
Jul 10 16:47:11 ||--killown> aí eu entendi que flush salva a pessoa no banco
Jul 10 16:47:12 ||--nosklo> depois que você adicionou a instância na sessão, você pode mexer com a instância à vontade, que a sessão vai detectar
Jul 10 16:47:27 ||--nosklo> ele gera o sql e executa, mas isso não é o suficiente
Jul 10 16:47:34 ||--nosklo> vc precisa comitar a transação
Jul 10 16:47:40 ||--nosklo> >>> s.commit()
Jul 10 16:47:40 ||--nosklo> 2010-07-10 16:48:44,071 INFO sqlalchemy.engine.base.Engine.0x...e30c COMMIT
Jul 10 16:47:42 ||--killown> >>> p.nome
Jul 10 16:47:42 ||--killown> u'nosklo manel'
Jul 10 16:47:55 ||--nosklo> agora, depois de commitar, está 100% salvo.
Jul 10 16:48:04 ||--killown> 2010-07-10 16:48:01,575 INFO sqlalchemy.engine.base.Engine.0x...d58c COMMIT
Jul 10 16:48:15 ||--killown> salvei
Jul 10 16:48:17 ||--nosklo> repare que .commit() já chama .flush() pra você, então vc geralmente pode pular o .flush()
Jul 10 16:48:27 ||--nosklo> e chamar .commit() direto
Jul 10 16:48:43 ||--killown> então o flush serve pra que
Jul 10 16:49:09 ||--nosklo> tem casos em q vc quer dar flush mas não quer comitar ainda, vc vai ver
Jul 10 16:49:16 ||--killown> certo
Jul 10 16:51:06 ||--killown> nosklo, e aí tá salvo o db
Jul 10 16:51:16 ||--nosklo> bom, vamos adicionar mais duas pessoas
Jul 10 16:51:17 ||--nosklo> >>> q = db.Pessoa()
Jul 10 16:51:17 ||--nosklo> >>> q.nome = u'manel'
Jul 10 16:51:17 ||--nosklo> >>> r = db.Pessoa()
Jul 10 16:51:18 ||--nosklo> >>> r.nome = u'werneck'
Jul 10 16:51:20 ||--nosklo> >>> s.add_all([q, r])
Jul 10 16:51:22 ||--nosklo> >>> s.commit()
Jul 10 16:51:24 ||--nosklo> 2010-07-10 16:52:16,567 INFO sqlalchemy.engine.base.Engine.0x...e30c BEGIN
Jul 10 16:51:26 ||--nosklo> 2010-07-10 16:52:16,568 INFO sqlalchemy.engine.base.Engine.0x...e30c INSERT INTO pessoas (nome) VALUES (?)
Jul 10 16:51:29 ||--nosklo> 2010-07-10 16:52:16,568 INFO sqlalchemy.engine.base.Engine.0x...e30c (u'manel',)
Jul 10 16:51:31 ||--nosklo> 2010-07-10 16:52:16,569 INFO sqlalchemy.engine.base.Engine.0x...e30c INSERT INTO pessoas (nome) VALUES (?)
Jul 10 16:51:34 ||--nosklo> 2010-07-10 16:52:16,569 INFO sqlalchemy.engine.base.Engine.0x...e30c (u'werneck',)
Jul 10 16:51:36 ||--nosklo> 2010-07-10 16:52:16,569 INFO sqlalchemy.engine.base.Engine.0x...e30c COMMIT
Jul 10 16:51:59 ||--killown> 2010-07-10 16:51:56,096 INFO sqlalchemy.engine.base.Engine.0x...d58c COMMIT
Jul 10 16:52:07 ||--nosklo> agora, você tem 3 pessoas no banco
Jul 10 16:52:11 ||--nosklo> veja só que interessante
Jul 10 16:52:26 ||--nosklo> >>> p.nome
Jul 10 16:52:26 ||--nosklo> 2010-07-10 16:53:00,016 INFO sqlalchemy.engine.base.Engine.0x...e30c BEGIN
Jul 10 16:52:26 ||--nosklo> 2010-07-10 16:53:00,017 INFO sqlalchemy.engine.base.Engine.0x...e30c SELECT pessoas.id AS pessoas_id, pessoas.nome AS pessoas_nome
Jul 10 16:52:26 ||--nosklo> FROM pessoas
Jul 10 16:52:26 ||--nosklo> WHERE pessoas.id = ?
Jul 10 16:52:28 ||--nosklo> 2010-07-10 16:53:00,017 INFO sqlalchemy.engine.base.Engine.0x...e30c (1,)
Jul 10 16:52:30 ||--nosklo> u'Jos\xe9 killown'
Jul 10 16:52:41 ||--killown> 2010-07-10 16:52:34,083 INFO sqlalchemy.engine.base.Engine.0x...d58c (1,)
Jul 10 16:52:41 ||--killown> u'nosklo manel'
Jul 10 16:52:55 ||--nosklo> quando você comitou a sessão, ele fechou, começou outra sessão
Jul 10 16:53:08 ||--nosklo> ao acessar o atributo nome da instância, ele foi lá e consultou pra ver se tinha mudado no banco
Jul 10 16:53:20 ||--killown> a tá
Jul 10 16:53:23 ||--nosklo> outra thread, processo ou até mesmo outro computador poderia ter mudado o nome no banco
Jul 10 16:54:06 ||--nosklo> por isso que você não mantem a sessão, vc cria, usa e descarta
Jul 10 16:54:20 ||--killown> aaa entendi
Jul 10 16:54:36 ||--nosklo> agora veja
Jul 10 16:55:04 ||--nosklo> >>> p.nome = u'killMown'
Jul 10 16:55:04 ||--nosklo> >>> s.flush()
Jul 10 16:55:04 ||--nosklo> 2010-07-10 16:55:59,992 INFO sqlalchemy.engine.base.Engine.0x...e30c UPDATE pessoas SET nome=? WHERE pessoas.id = ?
Jul 10 16:55:04 ||--nosklo> 2010-07-10 16:55:59,992 INFO sqlalchemy.engine.base.Engine.0x...e30c (u'killMown', 1)
Jul 10 16:55:04 ||--nosklo> >>> s.rollback()
Jul 10 16:55:06 ||--nosklo> 2010-07-10 16:56:04,003 INFO sqlalchemy.engine.base.Engine.0x...e30c ROLLBACK
Jul 10 16:55:16 ||--nosklo> eu mudei o nome, mas dei rollback nesta sessão
Jul 10 16:55:22 ||--nosklo> então nada do que eu fiz nela valeu
Jul 10 16:55:28 ||--nosklo> print p.nome vai imprimir o valor antigo
Jul 10 16:55:53 ||--nosklo> o rollback() tbm encerra a sessão, então começou uma nova, ele vai consultar no banco de novo e pegar o valor original
Jul 10 16:56:28 ||--killown> 2010-07-10 16:56:23,527 INFO sqlalchemy.engine.base.Engine.0x...d58c (1,)
Jul 10 16:56:28 ||--killown> u'nosklo manel'
Jul 10 16:56:34 ||--killown> no caso ainda continuou o mesmo
Jul 10 16:56:38 ||--nosklo> isso
Jul 10 16:56:40 ||--killown> mas acho que não segui ceto
Jul 10 16:56:51 ||--nosklo> exatamente, ia ficar o mesmo
Jul 10 16:57:05 ||--nosklo> vc deu rollback, então tudo q vc vez desde o ultimo commit, se cancelou
Jul 10 16:57:47 ||--nosklo> agora faz o seguinte, sai do interpretador, e roda python -i test_agenda.py
Jul 10 16:57:53 ||--nosklo> de novo
Jul 10 16:57:59 ||--nosklo> vc vai entrar, e não tem as instâncias
Jul 10 16:58:19 ||--killown> blz
Jul 10 16:58:30 ||--killown> python -i test_agenda.py
Jul 10 16:58:30 ||--killown> 2010-07-10 16:58:26,302 INFO sqlalchemy.engine.base.Engine.0x...958c PRAGMA table_info("pessoas")
Jul 10 16:58:30 ||--killown> 2010-07-10 16:58:26,302 INFO sqlalchemy.engine.base.Engine.0x...958c ()
Jul 10 16:58:46 ||--nosklo> sim, o create_all() consultou pra ver se a tabela existe
Jul 10 16:58:54 ||--nosklo> como já existia, ele não deu o CREATE TABLE de novo
Jul 10 16:59:19 ||--killown> certo
Jul 10 16:59:31 ||--nosklo> então, >>> s = db.Session()
Jul 10 16:59:35 ||--nosklo> crio outra sessão
Jul 10 16:59:44 ||--nosklo> vamos pegar a primeira pessoa que tiver no banco
Jul 10 16:59:51 ||--nosklo> p = s.query(db.Pessoa).first()
Jul 10 16:59:53 ||--killown> >>> s = db.Session()
Jul 10 16:59:53 ||--killown> >>>
Jul 10 17:00:06 ||--nosklo> 2010-07-10 17:00:27,964 INFO sqlalchemy.engine.base.Engine.0x...730c BEGIN
Jul 10 17:00:06 ||--nosklo> 2010-07-10 17:00:27,964 INFO sqlalchemy.engine.base.Engine.0x...730c SELECT pessoas.id AS pessoas_id, pessoas.nome AS pessoas_nome
Jul 10 17:00:06 ||--nosklo> FROM pessoas
Jul 10 17:00:06 ||--nosklo> LIMIT 1 OFFSET 0
Jul 10 17:00:06 ||--nosklo> 2010-07-10 17:00:27,964 INFO sqlalchemy.engine.base.Engine.0x...730c ()
Jul 10 17:00:10 ||--killown> >>> p.nome
Jul 10 17:00:10 ||--killown> u'nosklo manel'
Jul 10 17:00:12 ||--killown> uia
Jul 10 17:00:14 ||--nosklo> exatamente
Jul 10 17:00:25 ||--nosklo> ele gerou uma query com LIMIT 1
Jul 10 17:00:29 ||--nosklo> para pegar somente um registro
Jul 10 17:00:41 ||--nosklo> e criou a instancia pra vc
Jul 10 17:00:43 ||--killown> putz que rockcs
Jul 10 17:01:15 ||--nosklo> >>> for p in s.query(db.Pessoa):
Jul 10 17:01:15 ||--nosklo> ...     print p.nome
Jul 10 17:01:15 ||--nosklo> ...
Jul 10 17:01:23 ||--nosklo> vai consultar todas as pessoas
Jul 10 17:01:29 ||--nosklo> 2010-07-10 17:02:15,248 INFO sqlalchemy.engine.base.Engine.0x...730c SELECT pessoas.id AS pessoas_id, pessoas.nome AS pessoas_nome
Jul 10 17:01:29 ||--nosklo> FROM pessoas
Jul 10 17:01:30 ||--nosklo> 2010-07-10 17:02:15,248 INFO sqlalchemy.engine.base.Engine.0x...730c ()
Jul 10 17:01:33 ||--nosklo> hehehe
Jul 10 17:01:36 ||--killown> 2010-07-10 17:01:31,526 INFO sqlalchemy.engine.base.Engine.0x...958c ()
Jul 10 17:01:36 ||--killown> nosklo manel
Jul 10 17:01:36 ||--killown> manel
Jul 10 17:01:36 ||--killown> werneck
Jul 10 17:01:38 ||--killown> aehuaheuhuaehhaue
Jul 10 17:01:41 ||--killown> AEEEEE
Jul 10 17:02:08 ||--killown> vlw nosklo hauehuaeuhae agora sim deu pra entender
Jul 10 17:02:17 ||--nosklo> agora vem a parte mais legal
Jul 10 17:02:26 ||--killown> qual é
Jul 10 17:06:20 ||--nosklo> hg pull
Jul 10 17:06:22 ||--nosklo> hg update
Jul 10 17:06:37 ||--nosklo> e delete o banco para começarmos com o banco limpo de novo
Jul 10 17:07:12 ||--nosklo> rm /tmp/agenda.db
Jul 10 17:07:25 ||--nosklo> python -i test_agenda.py
Jul 10 17:07:31 ||--nosklo> ele vai criar a tabela de novo
Jul 10 17:07:40 ||--nosklo> só que agora ele vai criar a tabela telefones tbm
Jul 10 17:07:45 ||--nosklo> CREATE TABLE telefones (
Jul 10 17:07:45 ||--nosklo> id INTEGER NOT NULL,
Jul 10 17:07:45 ||--nosklo> id_pessoa INTEGER,
Jul 10 17:07:45 ||--nosklo> numero VARCHAR(20),
Jul 10 17:07:45 ||--nosklo> PRIMARY KEY (id),
Jul 10 17:07:46 ||--nosklo> FOREIGN KEY(id_pessoa) REFERENCES pessoas (id)
Jul 10 17:07:46 ||--killown> certo
Jul 10 17:07:50 ||--nosklo> )
Jul 10 17:07:55 ||--nosklo> abra o db.py
Jul 10 17:08:06 ||--nosklo> veja q eu só incluí a classe Telefone
Jul 10 17:08:32 ||--nosklo> nele eu criei um relationship - relacionamento
Jul 10 17:08:43 ||--nosklo> vamos usar q fica fácil de entender
Jul 10 17:08:45 ||--killown> CREATE TABLE telefones (
Jul 10 17:08:45 ||--killown> id INTEGER NOT NULL,
Jul 10 17:08:45 ||--killown> id_pessoa INTEGER,
Jul 10 17:08:45 ||--killown> numero VARCHAR(20),
Jul 10 17:08:45 ||--killown> PRIMARY KEY (id),
Jul 10 17:08:45 ||--killown> FOREIGN KEY(id_pessoa) REFERENCES pessoas (id)
Jul 10 17:08:52 ||--nosklo> criamos primeiro a sessão
Jul 10 17:08:57 ||--nosklo> s = db.Session()
Jul 10 17:09:02 ||--nosklo> vamos adicionar uma pessoa
Jul 10 17:09:06 ||--nosklo> p = db.Pessoa()
Jul 10 17:09:12 ||--nosklo> p.nome = u'manel'
Jul 10 17:09:14 ||--nosklo> s.add(p)
Jul 10 17:09:26 ||--nosklo> s.commit()
Jul 10 17:09:36 ||--killown> 2010-07-10 17:09:32,152 INFO sqlalchemy.engine.base.Engine.0x...ed4c COMMIT
Jul 10 17:10:00 ||--killown> >>> p.nome
Jul 10 17:10:00 ||--killown> 2010-07-10 17:09:49,742 INFO sqlalchemy.engine.base.Engine.0x...ed4c BEGIN
Jul 10 17:10:00 ||--killown> 2010-07-10 17:09:49,743 INFO sqlalchemy.engine.base.Engine.0x...ed4c SELECT pessoas.id AS pessoas_id, pessoas.nome AS pessoas_nome
Jul 10 17:10:00 ||--killown> FROM pessoas
Jul 10 17:10:00 ||--killown> WHERE pessoas.id = ?
Jul 10 17:10:00 ||--killown> 2010-07-10 17:09:49,743 INFO sqlalchemy.engine.base.Engine.0x...ed4c (1,)
Jul 10 17:10:00 ||--killown> u'manel'
Jul 10 17:10:08 ||--nosklo> agora, criamos um telefone pra ele
Jul 10 17:10:16 ||--nosklo> t = db.Telefone()
Jul 10 17:10:21 ||--nosklo> t.numero = '555-5555'
Jul 10 17:10:21 ||--killown> nosklo, pq na primeira vez enviou tudo isso?
Jul 10 17:10:29 ||--killown> e na segunda >>> p.nome
Jul 10 17:10:29 ||--killown> u'manel'
Jul 10 17:10:39 ||--nosklo> pq depois de fazer um commit(), vc iniciou outra sessão
Jul 10 17:10:44 ||--killown> a certo
Jul 10 17:10:48 ||--nosklo> logo tudo q vc faz é consultado no banco
Jul 10 17:10:52 ||--nosklo> pra ver se mudou
Jul 10 17:11:00 ||--nosklo> por isso as sessões tem q viver pouco
Jul 10 17:11:07 ||--killown> >>> t.numero
Jul 10 17:11:07 ||--killown> '555-5555'
Jul 10 17:11:19 ||--nosklo> agora vem o legal
Jul 10 17:11:25 ||--nosklo> p.telefones.append(t)
Jul 10 17:11:39 ||--killown> ahuehuae
Jul 10 17:11:45 ||--killown> essa eu entendi
Jul 10 17:11:58 ||--nosklo> s.commit()
Jul 10 17:12:07 ||--killown> 2010-07-10 17:12:03,520 INFO sqlalchemy.engine.base.Engine.0x...ed4c COMMIT
Jul 10 17:12:15 ||--nosklo> note que você adicionou o telefone ao manel
Jul 10 17:12:22 ||--nosklo> e não precisou adicionar na sessão
Jul 10 17:12:29 ||--nosklo> pq o manel já estava na sessão
Jul 10 17:12:37 ||--nosklo> vamos criar um celular
Jul 10 17:12:44 ||--nosklo> t2 = db.Telefone()
Jul 10 17:12:50 ||--nosklo> t2.numero = '9999-9999'
Jul 10 17:12:56 ||--nosklo> p.telefones.append(t2)
Jul 10 17:13:03 ||--killown> WHERE ? = telefones.id_pessoa
Jul 10 17:13:03 ||--killown> 2010-07-10 17:12:59,904 INFO sqlalchemy.engine.base.Engine.0x...ed4c (1,)
Jul 10 17:13:22 ||--killown> commit
Jul 10 17:13:24 ||--killown> 2010-07-10 17:13:18,560 INFO sqlalchemy.engine.base.Engine.0x...ed4c COMMIT
Jul 10 17:13:54 ||--nosklo> legal
Jul 10 17:14:06 ||--nosklo> agora olha só, vamos começar uma sessão do zero
Jul 10 17:14:09 ||--nosklo> se vc faz a consulta
Jul 10 17:14:39 ||--nosklo> p = s.query(db.Pessoa).first()
Jul 10 17:14:41 ||--nosklo> pegou a pessoa
Jul 10 17:14:50 ||--nosklo> 2010-07-10 17:15:42,066 INFO sqlalchemy.engine.base.Engine.0x...3acc BEGIN
Jul 10 17:14:50 ||--nosklo> 2010-07-10 17:15:42,067 INFO sqlalchemy.engine.base.Engine.0x...3acc SELECT pessoas.id AS pessoas_id, pessoas.nome AS pessoas_nome
Jul 10 17:14:50 ||--nosklo> FROM pessoas
Jul 10 17:14:50 ||--nosklo> LIMIT 1 OFFSET 0
Jul 10 17:14:50 ||--nosklo> 2010-07-10 17:15:42,067 INFO sqlalchemy.engine.base.Engine.0x...3acc ()
Jul 10 17:14:55 ||--nosklo> ele faz a query só na tabela pessoas
Jul 10 17:15:01 ||--nosklo> veja o "FROM pessoas"
Jul 10 17:15:07 ||--nosklo> aí vamos ver os telefones que essa pessoa tem
Jul 10 17:15:11 ||--nosklo> print p.telefones
Jul 10 17:15:22 ||--nosklo> 2010-07-10 17:16:23,037 INFO sqlalchemy.engine.base.Engine.0x...3acc SELECT telefones.id AS telefones_id, telefones.id_pessoa AS telefones_id_pessoa, telefones.numero AS telefones_numero
Jul 10 17:15:23 ||--nosklo> FROM telefones
Jul 10 17:15:23 ||--nosklo> WHERE ? = telefones.id_pessoa
Jul 10 17:15:28 ||--killown> perae nosklo eu sai do interpretador ainda
Jul 10 17:15:34 ||--nosklo> sim, eu tbm
Jul 10 17:15:45 ||--nosklo> ao voltar é só criar outra sessão
Jul 10 17:15:48 ||--nosklo> s = db.Session()
Jul 10 17:15:50 ||--nosklo> e boa
Jul 10 17:15:53 ||--killown> 2010-07-10 17:15:49,269 INFO sqlalchemy.engine.base.Engine.0x...9d4c ()
Jul 10 17:16:00 ||--nosklo> p = s.query(db.Pessoa).first()
Jul 10 17:16:00 ||--killown> pegou
Jul 10 17:16:06 ||--nosklo> print p.telefones
Jul 10 17:16:24 ||--killown> >>> print p.telefones
Jul 10 17:16:24 ||--killown> 2010-07-10 17:16:15,207 INFO sqlalchemy.engine.base.Engine.0x...9d4c SELECT telefones.id AS telefones_id, telefones.id_pessoa AS telefones_id_pessoa, telefones.numero AS telefones_numero
Jul 10 17:16:24 ||--killown> FROM telefones
Jul 10 17:16:24 ||--killown> WHERE ? = telefones.id_pessoa
Jul 10 17:16:24 ||--killown> 2010-07-10 17:16:15,207 INFO sqlalchemy.engine.base.Engine.0x...9d4c (1,)
Jul 10 17:16:24 ||--killown> [||--telefones.db.Telefone object at 0xa410a6c>, ||--telefones.db.Telefone object at 0xa410aec>]
Jul 10 17:16:24 ||--killown> >>> print p.telefones
Jul 10 17:16:24 ||--killown> [||--telefones.db.Telefone object at 0xa410a6c>, ||--telefones.db.Telefone object at 0xa410aec>]
Jul 10 17:16:27 ||--nosklo> ele faz a query na tabela telefones, WHERE id_pessoa seja o id dessa pessoa
Jul 10 17:16:43 ||--nosklo> p.telefones é uma lista contendo duas instâncias de Telefone
Jul 10 17:16:54 ||--killown> t1 e t2
Jul 10 17:16:55 ||--nosklo> t = p.telefones[0]
Jul 10 17:16:58 ||--nosklo> print t.numero
Jul 10 17:17:08 ||--nosklo> print p.telefones[1].numero
Jul 10 17:17:16 ||--killown> >>> t = p.telefones[0]
Jul 10 17:17:16 ||--killown> >>> print t.numero
Jul 10 17:17:16 ||--killown> 555-5555
Jul 10 17:17:16 ||--killown> >>> print p.telefones[1].numero
Jul 10 17:17:16 ||--killown> 9999-9999
Jul 10 17:17:17 ||--killown> ahuehuae
Jul 10 17:17:23 ||--nosklo> print t.pessoa
Jul 10 17:17:29 ||--nosklo> qual a pessoa desse telefone t?
Jul 10 17:17:36 ||--nosklo> print t.pessoa.nome
Jul 10 17:17:51 ||--killown> >>> print t.pessoa.nome
Jul 10 17:17:51 ||--killown> manel