Explicit imports make it easier for users to understand the examples.
Additionally a lot of the examples were fixed to work with the changes in the
0.5.x code base. One small correction to the Case expression. Thanks a bunch
to Adam Lowry! Fixes #717.
of the price on each Item (since those can change).
"""
-import logging
from datetime import datetime
-from sqlalchemy import *
-from sqlalchemy.orm import *
+from sqlalchemy import (create_engine, MetaData, Table, Column, Integer,
+ String, DateTime, Numeric, ForeignKey, and_)
+from sqlalchemy.orm import mapper, relation, create_session
# Uncomment these to watch database activity.
+#import logging
#logging.basicConfig(format='%(message)s')
#logging.getLogger('sqlalchemy.engine').setLevel(logging.INFO)
session = create_session()
# create our catalog
-session.save(Item('SA T-Shirt', 10.99))
-session.save(Item('SA Mug', 6.50))
-session.save(Item('SA Hat', 8.99))
-session.save(Item('MySQL Crowbar', 16.99))
+session.add(Item('SA T-Shirt', 10.99))
+session.add(Item('SA Mug', 6.50))
+session.add(Item('SA Hat', 8.99))
+session.add(Item('MySQL Crowbar', 16.99))
session.flush()
# function to return items from the DB
order.order_items.append(OrderItem(item('SA Mug')))
order.order_items.append(OrderItem(item('MySQL Crowbar'), 10.99))
order.order_items.append(OrderItem(item('SA Hat')))
-session.save(order)
+session.add(order)
session.flush()
-session.clear()
+session.expunge_all()
# query the order, print items
order = session.query(Order).filter_by(customer_name='john smith').one()
the usage of the associationproxy extension."""
from datetime import datetime
-from sqlalchemy import *
-from sqlalchemy.orm import *
+from sqlalchemy import (create_engine, MetaData, Table, Column, Integer,
+ String, DateTime, Float, ForeignKey, and_)
+from sqlalchemy.orm import mapper, relation, create_session
from sqlalchemy.ext.associationproxy import AssociationProxy
engine = create_engine('sqlite://')
session.add(order)
session.flush()
-session.clear()
+session.expunge_all()
# query the order, print items
order = session.query(Order).filter_by(customer_name='john smith').one()
presents a more refined version of some of these patterns.
"""
-from sqlalchemy import *
-from sqlalchemy.orm import *
+from sqlalchemy import MetaData, Table, Column, Integer, String, ForeignKey
+from sqlalchemy.orm import (mapper, relation, create_session, MapperExtension,
+ object_session)
+
meta = MetaData('sqlite://')
meta.bind.echo = True
org.members.append(Member('member two'))
org.members.append(Member('member three'))
-sess.save(org)
+sess.add(org)
print "-------------------------\nflush one - save org + 3 members"
sess.flush()
-sess.clear()
+sess.expunge_all()
# reload. load the org and some child members
print "-------------------------\nload subset of members"
members = org.member_query.filter(member_table.c.name.like('%member t%')).all()
print members
-sess.clear()
+sess.expunge_all()
# reload. create some more members and flush, without loading any of the original members
print "-------------------------\nflush two - save 3 more members"
sess.flush()
-sess.clear()
+sess.expunge_all()
org = sess.query(Organization).get(org.org_id)
# now delete. note that this will explictily delete members four, five and six because they are in the session,
with a custom attribute system as well.
"""
-from sqlalchemy import *
-from sqlalchemy.orm import *
+from sqlalchemy import (create_engine, MetaData, Table, Column, Integer, Text,
+ ForeignKey)
+from sqlalchemy.orm import (mapper, relation, create_session,
+ InstrumentationManager)
from sqlalchemy.orm.attributes import set_attribute, get_attribute, del_attribute, is_instrumented
from sqlalchemy.orm.collections import collection_adapter
assert isinstance(a1.bs, MyCollection)
sess = create_session()
- sess.save(a1)
+ sess.add(a1)
sess.flush()
- sess.clear()
+ sess.expunge_all()
a1 = sess.query(A).get(a1.id)
a1.bs.remove(a1.bs[0])
sess.flush()
- sess.clear()
+ sess.expunge_all()
a1 = sess.query(A).get(a1.id)
assert len(a1.bs) == 1
if __name__ == '__main__':
- from sqlalchemy import *
- from sqlalchemy.orm import *
+ from sqlalchemy import Column, Integer, String, ForeignKey
+ from sqlalchemy.orm import relation
from sqlalchemy.ext.declarative import declarative_base
class Base(object):
m1.related.mapped.append(MyMappedClass(data='m2'))
del m1.data
-
\ No newline at end of file
+
### Example code
-from sqlalchemy import *
-from sqlalchemy.orm import *
+from sqlalchemy import MetaData, Table, Column, Integer
+from sqlalchemy.orm import mapper, create_session
metadata = MetaData('sqlite://')
metadata.bind.echo = True
intervals = [Interval1(1,4), Interval1(3,15), Interval1(11,16)]
for interval in intervals:
- session.save(interval)
- session.save(Interval2(interval.start, interval.length))
+ session.add(interval)
+ session.add(Interval2(interval.start, interval.length))
session.flush()
print "Clear the cache and do some queries"
-session.clear()
+session.expunge_all()
for Interval in (Interval1, Interval2):
print "Querying using interval class %s" % Interval.__name__
self.collection.append(value)\r
\r
from sqlalchemy.ext.declarative import declarative_base\r
-from sqlalchemy import *\r
-from sqlalchemy.orm import *\r
+from sqlalchemy import create_engine, Column, Integer, String, ForeignKey\r
+from sqlalchemy.orm import sessionmaker, dynamic_loader\r
\r
Base = declarative_base(engine=create_engine('sqlite://'))\r
\r
"""
################################# PART I - Imports/Coniguration ###########################################
-from sqlalchemy import *
-from sqlalchemy.orm import *
+from sqlalchemy import (MetaData, Table, Column, Integer, String, ForeignKey,
+ Unicode, and_)
+from sqlalchemy.orm import mapper, relation, create_session, lazyload
import sys, os, StringIO, re
#logging.getLogger('sqlalchemy.engine').setLevel(logging.DEBUG)
-from elementtree import ElementTree
-from elementtree.ElementTree import Element, SubElement
+from xml.etree import ElementTree
meta = MetaData()
meta.bind = 'sqlite://'
for file in ('test.xml', 'test2.xml', 'test3.xml'):
filename = os.path.join(os.path.dirname(sys.argv[0]), file)
doc = ElementTree.parse(filename)
- session.save(Document(file, doc))
+ session.add(Document(file, doc))
print "\nSaving three documents...", line
session.flush()
print "Done."
# clear session (to illustrate a full load), restore
-session.clear()
+session.expunge_all()
print "\nFull text of document 'text.xml':", line
document = session.query(Document).filter_by(filename="test.xml").first()
"""
################################# PART I - Imports/Configuration ###########################################
-from sqlalchemy import *
-from sqlalchemy.orm import *
+from sqlalchemy import (MetaData, Table, Column, Integer, String, ForeignKey,
+ Unicode, and_)
+from sqlalchemy.orm import mapper, relation, create_session, lazyload
import sys, os, StringIO, re
#logging.getLogger('sqlalchemy.engine').setLevel(logging.DEBUG)
-from elementtree import ElementTree
-from elementtree.ElementTree import Element, SubElement
+from xml.etree import ElementTree
meta = MetaData()
meta.bind = 'sqlite://'
for file in ('test.xml', 'test2.xml', 'test3.xml'):
filename = os.path.join(os.path.dirname(sys.argv[0]), file)
doc = ElementTree.parse(filename)
- session.save(Document(file, doc))
+ session.add(Document(file, doc))
print "\nSaving three documents...", line
session.flush()
print "Done."
# clear session (to illustrate a full load), restore
-session.clear()
+session.expunge_all()
print "\nFull text of document 'text.xml':", line
document = session.query(Document).filter_by(filename="test.xml").first()
styles of persistence are identical, as is the structure of the main Document class.
"""
-from sqlalchemy import *
-from sqlalchemy.orm import *
+from sqlalchemy import (create_engine, MetaData, Table, Column, Integer, String,
+ PickleType)
+from sqlalchemy.orm import mapper, create_session
import sys, os
# uncomment to show SQL statements and result sets
#logging.getLogger('sqlalchemy.engine').setLevel(logging.DEBUG)
-from elementtree import ElementTree
+from xml.etree import ElementTree
engine = create_engine('sqlite://')
meta = MetaData(engine)
# save to DB
session = create_session()
-session.save(Document("test.xml", doc))
+session.add(Document("test.xml", doc))
session.flush()
# clear session (to illustrate a full load), restore
-session.clear()
+session.expunge_all()
document = session.query(Document).filter_by(filename="test.xml").first()
# print
"""a directed graph example."""
-from sqlalchemy import *
-from sqlalchemy.orm import *
+from sqlalchemy import MetaData, Table, Column, Integer, ForeignKey
+from sqlalchemy.orm import mapper, relation, create_session
import logging
logging.basicConfig()
n1.add_neighbor(n3)
n2.add_neighbor(n1)
-[session.save(x) for x in [n1, n2, n3, n4, n5, n6, n7]]
+[session.add(x) for x in [n1, n2, n3, n4, n5, n6, n7]]
session.flush()
-session.clear()
+session.expunge_all()
n2 = session.query(Node).get(2)
n3 = session.query(Node).get(3)
"""
-from sqlalchemy import *
-from sqlalchemy.orm import *
-from sqlalchemy.orm import attributes
+from sqlalchemy import (create_engine, Column, Integer, String, select, case,
+ func)
+from sqlalchemy.orm import sessionmaker, MapperExtension, aliased
from sqlalchemy.ext.declarative import declarative_base
engine = create_engine('sqlite://', echo=True)
"""illustrates one way to use a custom pickler that is session-aware."""
-from sqlalchemy import *
-from sqlalchemy.orm import *
+from sqlalchemy import MetaData, Table, Column, Integer, String, PickleType
+from sqlalchemy.orm import (mapper, create_session, MapperExtension,
+ class_mapper, EXT_CONTINUE)
from sqlalchemy.orm.session import object_session
from cStringIO import StringIO
from pickle import Pickler, Unpickler
if getattr(obj, "id", None) is None:
sess = MyPickler.sessions.current
newsess = create_session(bind=sess.connection(class_mapper(Bar)))
- newsess.save(obj)
+ newsess.add(obj)
newsess.flush()
key = "%s:%s" % (type(obj).__name__, obj.id)
return key
sess = create_session()
f = Foo()
f.bar = Bar('some bar')
-sess.save(f)
+sess.add(f)
sess.flush()
-sess.clear()
+sess.expunge_all()
del MyPickler.sessions.current
"""
-from sqlalchemy import *
-from sqlalchemy.orm import *
+from sqlalchemy import MetaData, Table, Column, Integer, String, and_
+from sqlalchemy.orm import (mapper, relation, create_session, class_mapper,
+ backref)
metadata = MetaData('sqlite://')
a3.street = '444 park ave.'
sess = create_session()
-sess.save(u1)
-sess.save(o1)
+sess.add(u1)
+sess.add(o1)
sess.flush()
-sess.clear()
+sess.expunge_all()
# query objects, get their addresses
poly_assoc_generic.py.
"""
-from sqlalchemy import *
-from sqlalchemy.orm import *
+from sqlalchemy import MetaData, Table, Column, Integer, String, ForeignKey
+from sqlalchemy.orm import mapper, relation, create_session, class_mapper
metadata = MetaData('sqlite://')
o1.address.street = '444 park ave.'
sess = create_session()
-sess.save(u1)
-sess.save(o1)
+sess.add(u1)
+sess.add(o1)
sess.flush()
-sess.clear()
+sess.expunge_all()
# query objects, get their addresses
"interface".
"""
-from sqlalchemy import *
-from sqlalchemy.orm import *
+from sqlalchemy import MetaData, Table, Column, Integer, String, ForeignKey
+from sqlalchemy.orm import mapper, relation, create_session, class_mapper
metadata = MetaData('sqlite://')
o1.address.street = '444 park ave.'
sess = create_session()
-sess.save(u1)
-sess.save(o1)
+sess.add(u1)
+sess.add(o1)
sess.flush()
-sess.clear()
+sess.expunge_all()
# query objects, get their addresses
-from sqlalchemy import *
-from sqlalchemy.orm import *
+from sqlalchemy import create_engine, MetaData, Table, Column, Integer, String
+from sqlalchemy.orm import mapper, create_session, polymorphic_union
metadata = MetaData()
e1 = Engineer("wally", "engineer1")
e2 = Engineer("dilbert", "engineer2")
-session.save(m1)
-session.save(e1)
-session.save(e2)
+session.add(m1)
+session.add(e1)
+session.add(e2)
session.flush()
-employees = session.query(Employee).select()
+employees = session.query(Employee)
print [e for e in employees]
-from sqlalchemy import *
-from sqlalchemy.orm import *
+from sqlalchemy import MetaData, Table, Column, Integer, String, ForeignKey
+from sqlalchemy.orm import mapper, relation, create_session
import sets
# this example illustrates a polymorphic load of two classes
person_join = people.outerjoin(engineers).outerjoin(managers)
-person_mapper = mapper(Person, people, select_table=person_join,polymorphic_on=people.c.type, polymorphic_identity='person')
+person_mapper = mapper(Person, people, polymorphic_on=people.c.type, polymorphic_identity='person')
mapper(Engineer, engineers, inherits=person_mapper, polymorphic_identity='engineer')
mapper(Manager, managers, inherits=person_mapper, polymorphic_identity='manager')
mapper(Company, companies, properties={
- 'employees': relation(Person, lazy=False, private=True, backref='company')
+ 'employees': relation(Person, lazy=False, backref='company', cascade="all, delete-orphan")
})
session = create_session(echo_uow=False)
c.employees.append(Person(name='joesmith', status='HHH'))
c.employees.append(Engineer(name='wally', status='CGG', engineer_name='engineer2', primary_language='python'))
c.employees.append(Manager(name='jsmith', status='ABA', manager_name='manager2'))
-session.save(c)
+session.add(c)
print session.new
session.flush()
-session.clear()
+session.expunge_all()
c = session.query(Company).get(1)
for e in c.employees:
- print e, e._instance_key, e.company
+ print e, e._sa_instance_state.key, e.company
assert sets.Set([e.name for e in c.employees]) == sets.Set(['pointy haired boss', 'dilbert', 'joesmith', 'wally', 'jsmith'])
print "\n"
-dilbert = session.query(Person).get_by(name='dilbert')
-dilbert2 = session.query(Engineer).get_by(name='dilbert')
+dilbert = session.query(Person).filter_by(name='dilbert').one()
+dilbert2 = session.query(Engineer).filter_by(name='dilbert').one()
assert dilbert is dilbert2
dilbert.engineer_name = 'hes dibert!'
session.flush()
-session.clear()
+session.expunge_all()
c = session.query(Company).get(1)
for e in c.employees:
- print e, e._instance_key
+ print e, e._sa_instance_state.key
session.delete(c)
session.flush()
-from sqlalchemy import *
-from sqlalchemy.orm import *
+from sqlalchemy import MetaData, Table, Column, Integer, String, ForeignKey
+from sqlalchemy.orm import mapper, relation, create_session
metadata = MetaData('sqlite://')
metadata.bind.echo = 'debug'
mapper(Company, companies, properties={
- 'employees': relation(Person, lazy=True, private=True, backref='company')
+ 'employees': relation(Person, lazy=True, backref='company')
})
session = create_session()
c.employees.append(Person(name='joesmith', status='HHH'))
c.employees.append(Engineer(name='wally', status='CGG', engineer_name='engineer2', primary_language='python'))
c.employees.append(Manager(name='jsmith', status='ABA', manager_name='manager2'))
-session.save(c)
+session.add(c)
session.flush()
-session.clear()
+session.expunge_all()
c = session.query(Company).get(1)
for e in c.employees:
- print e, e._instance_key, e.company
+ print e, e._sa_instance_state.key, e.company
print "\n"
-dilbert = session.query(Person).get_by(name='dilbert')
-dilbert2 = session.query(Engineer).get_by(name='dilbert')
+dilbert = session.query(Person).filter_by(name='dilbert').one()
+dilbert2 = session.query(Engineer).filter_by(name='dilbert').one()
assert dilbert is dilbert2
dilbert.engineer_name = 'hes dibert!'
session.flush()
-session.clear()
+session.expunge_all()
c = session.query(Company).get(1)
for e in c.employees:
- print e, e._instance_key
+ print e, e._sa_instance_state.key
session.delete(c)
session.flush()
* a standalone operator example.
The implementation is limited to only public, well known
-and simple to use extension points, with the exception
-of one temporary monkeypatch in the DDL extension.
-Future SQLAlchemy expansion points may allow more seamless
-integration of some features.
-
+and simple to use extension points. Future SQLAlchemy
+expansion points may allow more seamless integration of
+some features.
+
"""
from sqlalchemy.orm.interfaces import AttributeExtension
# illustrate usage
if __name__ == '__main__':
- from sqlalchemy import *
- from sqlalchemy.orm import *
+ from sqlalchemy import (create_engine, MetaData, Column, Integer, String,
+ func, literal, select)
+ from sqlalchemy.orm import sessionmaker, column_property
from sqlalchemy.ext.declarative import declarative_base
engine = create_engine('postgres://scott:tiger@localhost/gistest', echo=True)
"""
# step 1. imports
-from sqlalchemy import *
-from sqlalchemy.orm import *
+from sqlalchemy import (create_engine, MetaData, Table, Column, Integer,
+ String, ForeignKey, Float, DateTime)
+from sqlalchemy.orm import sessionmaker, mapper, relation
from sqlalchemy.orm.shard import ShardedSession
from sqlalchemy.sql import operators
from sqlalchemy import sql
# step 2. databases
echo = True
-db1 = create_engine('sqlite:///shard1.db', echo=echo)
-db2 = create_engine('sqlite:///shard2.db', echo=echo)
-db3 = create_engine('sqlite:///shard3.db', echo=echo)
-db4 = create_engine('sqlite:///shard4.db', echo=echo)
+db1 = create_engine('sqlite://', echo=echo)
+db2 = create_engine('sqlite://', echo=echo)
+db3 = create_engine('sqlite://', echo=echo)
+db4 = create_engine('sqlite://', echo=echo)
# step 3. create session function. this binds the shard ids
north_american_cities = sess.query(WeatherLocation).filter(WeatherLocation.continent == 'North America')
assert [c.city for c in north_american_cities] == ['New York', 'Toronto']
-asia_and_europe = sess.query(WeatherLocation).filter(WeatherLocation.continent.in_('Europe', 'Asia'))
+asia_and_europe = sess.query(WeatherLocation).filter(WeatherLocation.continent.in_(['Europe', 'Asia']))
assert set([c.city for c in asia_and_europe]) == set(['Tokyo', 'London', 'Dublin'])
future version of SQLAlchemy.
"""
-from sqlalchemy.orm.interfaces import PropComparator, MapperProperty
-from sqlalchemy.orm import session as sessionlib, comparable_property
+from sqlalchemy.orm.interfaces import PropComparator
+from sqlalchemy.orm import comparable_property
# Using the VerticalPropertyDictMixin from the base example
from dictlike import VerticalPropertyDictMixin
if __name__ == '__main__':
- from sqlalchemy import *
+ from sqlalchemy import (MetaData, Table, Column, Integer, Unicode,
+ ForeignKey, UnicodeText, and_, not_, or_, String, Boolean, cast, text,
+ null, case)
from sqlalchemy.orm import mapper, relation, create_session
from sqlalchemy.orm.collections import attribute_mapped_collection
stoat[u'cuteness'] = 7
stoat[u'weasel-like'] = True
- session.save(stoat)
+ session.add(stoat)
session.flush()
- session.clear()
+ session.expunge_all()
critter = session.query(Animal).filter(Animal.name == u'stoat').one()
print critter[u'color']
marten[u'cuteness'] = 5
marten[u'weasel-like'] = True
marten[u'poisonous'] = False
- session.save(marten)
+ session.add(marten)
shrew = Animal(u'shrew')
shrew[u'cuteness'] = 5
shrew[u'weasel-like'] = False
shrew[u'poisonous'] = True
- session.save(shrew)
+ session.add(shrew)
session.flush()
q = (session.query(Animal).
if __name__ == '__main__':
- from sqlalchemy import *
+ from sqlalchemy import (MetaData, Table, Column, Integer, Unicode,
+ ForeignKey, UnicodeText, and_, not_)
from sqlalchemy.orm import mapper, relation, create_session
from sqlalchemy.orm.collections import attribute_mapped_collection
# stoat.facts collection:
print stoat.facts[u'color']
- session.save(stoat)
+ session.add(stoat)
session.flush()
- session.clear()
+ session.expunge_all()
critter = session.query(Animal).filter(Animal.name == u'stoat').one()
print critter[u'color']
marten = Animal(u'marten')
marten[u'color'] = u'brown'
marten[u'cuteness'] = u'somewhat'
- session.save(marten)
+ session.add(marten)
shrew = Animal(u'shrew')
shrew[u'cuteness'] = u'somewhat'
shrew[u'poisonous-part'] = u'saliva'
- session.save(shrew)
+ session.add(shrew)
loris = Animal(u'slow loris')
loris[u'cuteness'] = u'fairly'
loris[u'poisonous-part'] = u'elbows'
- session.save(loris)
+ session.add(loris)
session.flush()
q = (session.query(Animal).
represented in distinct database rows. This allows objects to be created with dynamically changing
fields that are all persisted in a normalized fashion."""
-from sqlalchemy import *
-from sqlalchemy.orm import *
+from sqlalchemy import (create_engine, MetaData, Table, Column, Integer, String,
+ ForeignKey, PickleType, DateTime, and_)
+from sqlalchemy.orm import mapper, relation, sessionmaker, scoped_session
from sqlalchemy.orm.collections import mapped_collection
import datetime
whenlist = [(_literal_as_binds(c).self_group(), _literal_as_binds(r)) for (c, r) in whens]
else:
whenlist = [(_no_literals(c).self_group(), _literal_as_binds(r)) for (c, r) in whens]
-
+
if whenlist:
type_ = list(whenlist[-1])[-1].type
else:
type_ = None
-
- self.value = value
+
+ if value is None:
+ self.value = None
+ else:
+ self.value = _literal_as_binds(value)
+
self.type = type_
self.whens = whenlist
if else_ is not None:
@property
def _from_objects(self):
- return itertools.chain(*[x._from_objects for x in self.get_children()])
+ return list(itertools.chain(*[x._from_objects for x in self.get_children()]))
class Function(ColumnElement, FromClause):
"""Describe a SQL function."""
projects / thirdparty / sqlalchemy / sqlalchemy.git / commitdiff
