def begin(self, timeout=None):
self.connection = yield from self.driver.acquire()
self.cursor = yield from self.connection.cursor(timeout)
log.info('begin transaction #{}'.format(id(self)))
renderer = registry.get(interfaces.IDialect)()
stmt = renderer.render_begin_transaction()
yield from self.cursor.execute(stmt)
return self
def begin(self, timeout=None):
self.connection = yield from self.driver.acquire()
self.cursor = yield from self.connection.cursor(timeout)
log.info('begin transaction #{}'.format(id(self)))
renderer = registry.get(interfaces.IDialect)()
stmt = renderer.render_begin_transaction()
yield from self.cursor.execute(stmt)
return self
def test_registry(self):
from zope.interface import Interface, implementer
from aiorm import registry
class IAdaptable(Interface):
pass
class IAdapter(Interface):
pass
class IAdapter2(Interface):
pass
@implementer(IAdaptable)
class Adaptable:
pass
@implementer(IAdapter)
class Adapter:
pass
@implementer(IAdapter2)
class Adapter2:
pass
self.assertRaises(NotImplementedError, registry.get, IAdapter)
registry.register(Adapter, adapt=IAdaptable) # introspect iface
self.assertRaises(ValueError, registry.register, Adapter, adapt=IAdaptable)
registry.register(Adaptable, IAdaptable, adapt=IAdaptable) # explicit
registry.register(Adapter2, adapt=Adaptable)
# 3 "types" accepted for the adapt parameter
self.assertEqual(registry.get(IAdapter, adapt=IAdaptable), Adapter)
self.assertEqual(registry.get(IAdapter, adapt=Adaptable), Adapter)
self.assertEqual(registry.get(IAdapter, adapt=Adaptable()), Adapter)
self.assertEqual(registry.get(IAdaptable, adapt=IAdaptable), Adaptable)
self.assertEqual(registry.get(IAdaptable, adapt=Adaptable), Adaptable)
registry.unregister(Adapter, IAdaptable)
self.assertRaises(NotImplementedError, registry.get, IAdapter, adapt=IAdaptable)
registry.unregister(Adapter)
registry.unregister(Adapter2)
def rollback(self):
try:
if not self.cursor:
raise RuntimeError('transaction #{} not begun'.format(id(self)))
log.warning('rolling back transaction #{}'.format(id(self)))
renderer = registry.get(interfaces.IDialect)()
stmt = renderer.render_rollback_transaction()
yield from self.cursor.execute(stmt)
finally:
self._release()
def __getattr__(self, key):
"""
Use zope.interface for easy extensability.
If you want to had your own statement, register your own interface,
with your own implementation in aiorm registry.
"""
iface = 'I' + ''.join(txt.capitalize() for txt in key.split('_'))
iface = getattr(interfaces, iface)
self._child = registry.get(iface)(self)
return self._child
def commit(self):
try:
if not self.cursor:
raise RuntimeError('transaction #{} not begun'.format(id(self)))
log.info('commiting transaction #{}'.format(id(self)))
renderer = registry.get(interfaces.IDialect)()
stmt = renderer.render_commit_transaction()
yield from self.cursor.execute(stmt)
finally:
self._release()
def __getattr__(self, key):
"""
Use zope.interface for easy extensability.
If you want to had your own statement, register your own interface,
with your own implementation in aiorm registry.
"""
iface = 'I' + ''.join(txt.capitalize() for txt in key.split('_'))
iface = getattr(interfaces, iface)
self._child = registry.get(iface)(self)
return self._child
def __getattr__(self, key):
"""
Use zope.interface for easy extensability.
If you want to had your own statement, register your own interface,
with your own implementation in aiorm registry.
"""
iface = ['I'] + [word.capitalize() for word in key.split('_')]
iface = getattr(interfaces, ''.join(iface))
self._child = registry.get(iface)(self._query)
return self._child
def __getattr__(self, key):
"""
Use zope.interface for easy extensability.
If you want to had your own statement, register your own interface,
with your own implementation in aiorm registry.
"""
iface = ['I'] + [word.capitalize() for word in key.split('_')]
iface = getattr(interfaces, ''.join(iface))
self._child = registry.get(iface)(self._query)
return self._child
def rollback(self):
try:
if not self.cursor:
raise RuntimeError('transaction #{} not begun'.format(
id(self)))
log.warning('rolling back transaction #{}'.format(id(self)))
renderer = registry.get(interfaces.IDialect)()
stmt = renderer.render_rollback_transaction()
yield from self.cursor.execute(stmt)
finally:
self._release()
def commit(self):
try:
if not self.cursor:
raise RuntimeError('transaction #{} not begun'.format(
id(self)))
log.info('commiting transaction #{}'.format(id(self)))
renderer = registry.get(interfaces.IDialect)()
stmt = renderer.render_commit_transaction()
yield from self.cursor.execute(stmt)
finally:
self._release()
def aiotest():
from aiorm import registry
from aiorm.orm import Transaction
from aiorm.orm import interfaces
yield from registry.connect('/sample')
cursor = registry.get(interfaces.IDialect)()
cursor.configure_mock(**{'render_rollback_transaction.return_value':
'rollback_transaction'})
transaction = yield from Transaction('sample').begin()
yield from transaction.rollback()
cursor.render_rollback_transaction.assert_called_once_with()
self.assertEqual(driver.DummyCursor.last_query,
'rollback_transaction')
yield from registry.disconnect('sample')
def aiotest():
from aiorm import registry
from aiorm.orm import Transaction
from aiorm.orm import interfaces
yield from registry.connect('/sample')
cursor = registry.get(interfaces.IDialect)()
cursor.configure_mock(
**
{'render_begin_transaction.return_value': 'begin_transaction'})
transaction = Transaction('sample')
yield from transaction.begin()
cursor.render_begin_transaction.assert_called_once_with()
self.assertEqual(driver.DummyCursor.last_query,
'begin_transaction')
yield from registry.disconnect('sample')
def render_sql(self):
renderer = registry.get(interfaces.IDialect)()
renderer.render_delete(*self._args, **self._kwargs)
return renderer.query, renderer.parameters
def render_sql(self):
renderer = registry.get(interfaces.IDialect)()
renderer.render_select(*self._args, **self._kwargs)
if self._child:
self._child.render_sql(renderer)
return renderer.query, renderer.parameters
def render_sql(self):
renderer = registry.get(interfaces.ICreateTableDialect)()
renderer.render_create_table(*self._args, **self._kwargs)
return renderer.query, []
def render_sql(self):
renderer = registry.get(interfaces.IDialect)()
renderer.render_delete(*self._args, **self._kwargs)
return renderer.query, renderer.parameters
