Python sqlalchemy 模块,update() 实例源码
我们从Python开源项目中,提取了以下50个代码示例,用于说明如何使用sqlalchemy.update()。
def upsert_message_localization(message_name, language_id, message_title, message_text):
'''
Add or update a message localization. Returns new or updated localization with relation to message preloaded.
'''
with session_scope() as session:
message = session.query(model.Message).filter(model.Message.name == message_name).one()
message_localization = session.query(model.MessageLocalization).\
filter(model.MessageLocalization.message == message).\
filter(model.MessageLocalization.language_id == language_id).\
one_or_none()
if message_localization is not None:
message_localization.message_title = message_title
message_localization.message_text = message_text
else:
message_localization = model.MessageLocalization(message=message, language_id=language_id,
message_title=message_title, message_text=message_text)
session.add(message_localization)
session.commit()
session.refresh(message_localization)
session.refresh(message_localization.message)
return message_localization
def __call__(self, *c, **kwargs):
o = self.opts.copy()
o.update(kwargs)
tokens = len(self.__names)
if tokens == 2:
package, fname = self.__names
elif tokens == 1:
package, fname = "_default", self.__names[0]
else:
package = None
if package is not None and \
package in functions._registry and \
fname in functions._registry[package]:
func = functions._registry[package][fname]
return func(*c, **o)
return Function(self.__names[-1],
packagenames=self.__names[0:-1], **o)
# "func" global - i.e. func.count()
def update(self):
"""
Update followers and following
:return: New follower count,Lost follower count,New following count,Lost following count
"""
# Update followers
self._logger.info(u"Updating followers...")
n_follower, d_follower = self._update_friends(self._twitter_con.get_followers_cursor(), follower=True)
# Update following
self._logger.info(u"Updating followings...")
n_following, d_following = self._update_friends(self._twitter_con.get_following_cursor(), follower=False)
# Insert a statistic
self.update_statistics()
return n_follower, d_follower, n_following, d_following
# end update
# Get followers cursor
def update_user(request):
"""
update the user level
:param request:
:return:
"""
user = request.db_session.query(LedUser).filter(LedUser.id == request.matchdict['user_id']).first()
if user is not None:
level = request.POST.get('access_level', None)
if level is not None and int(level) in [0, 2]:
user.access_level = int(level)
log(request, 'Updated user {} to level {}'.format(user.email, level))
return {'message': 'success'}
else:
return {'message': "nothing changed"}
def _after_flush_handler(session, flush_context):
handlers = [
(_versioned_delete, session.deleted),
(_versioned_insert, session.new),
(_versioned_update, session.dirty),
]
for handler, rows in handlers:
for row in rows:
if isinstance(row, VAModelMixin):
if not hasattr(row, 'ArchiveTable'):
raise LogTableCreationError('Need to register va tables!!')
user_id = getattr(row, '_updated_by', None)
va_id = handler(row, session, user_id)
if va_id:
Model = type(row)
where_clause = utils.generate_and_clause(
Model, row, row.va_version_columns
)
session.execute(sa.update(Model, values={'va_id': va_id}).where(where_clause))
row.va_id = va_id
def upgrade():
bind = op.get_bind()
### commands auto generated by Alembic - please adjust! ###
op.add_column('exercises', sa.Column('chapter_id', sa.Integer(), nullable=True))
op.add_column('exercises', sa.Column('section_id', sa.Column('book_row_id', nullable=True))
op.add_column('subjects', sa.Column('book_url', sa.String(), nullable=True))
### end Alembic commands ###
data = [
{'id': 1, 'book_url': 'https://staging-tutor.cnx.org/contents/d52e93f4-8653-4273-86da-3850001c0786'},
{'id': 2, 'book_url': 'https://staging-tutor.cnx.org/contents/334f8b61-30eb-4475-8e05-5260a4866b4b'}
]
for item in data:
update = sa.update(subject_table)\
.where(subject_table.c.id == item['id'])\
.values(dict(book_url=item['book_url']))
bind.execute(update)
def where(self, whereclause):
"""return a new update() construct with the given expression added to
its WHERE clause,joined to the existing clause via AND,if any.
"""
if self._whereclause is not None:
self._whereclause = and_(self._whereclause,
_literal_as_text(whereclause))
else:
self._whereclause = _literal_as_text(whereclause)
def _extra_froms(self):
# Todo: this Could be made memoized
# if the memoization is reset on each generative call.
froms = []
seen = set([self.table])
if self._whereclause is not None:
for item in _from_objects(self._whereclause):
if not seen.intersection(item._cloned_set):
froms.append(item)
seen.update(item._cloned_set)
return froms
def update_canonicals(canonicals):
'''
Update canonical data for android devices.
'''
global ENGINE
binding = [{"p_{}".format(k): v for k, v in canonical.items()} for canonical in canonicals]
device_table = model.Metadata.tables['device']
stmt = update(device_table).\
values(device_token_new=bindparam('p_new_token')).\
where(and_(device_table.c.login_id == bindparam('p_login_id'),
func.coalesce(device_table.c.device_token_new, device_table.c.device_token) == bindparam('p_old_token')))
ENGINE.execute(stmt, binding)
with session_scope() as session:
query = text('SELECT keep_max_users_per_device( \
(:platform_id)::int2,:device_token,(:max_users_per_device)::int2)')
for canonical in canonicals:
session.execute(query,
{'platform_id': constants.PLATFORM_ANDROID,
'device_token': canonical['new_token'],
'max_users_per_device': config.max_users_per_device
})
session.execute(query,
{'platform_id': constants.PLATFORM_ANDROID_TABLET,
'max_users_per_device': config.max_users_per_device
})
session.commit()
def update_unregistered_devices(unregistered):
'''
Update data for unregistered Android devices.
Unregistered device will not receive notifications and will be deleted when number of devices exceeds maximum.
'''
global ENGINE
binding = [{"p_{}".format(k): v for k, v in u.items()} for u in unregistered]
device_table = model.Metadata.tables['device']
stmt = update(device_table).\
values(unregistered_ts=func.Now()).\
where(and_(device_table.c.login_id == bindparam('p_login_id'), device_table.c.device_token) == bindparam('p_device_token')))
ENGINE.execute(stmt, binding)
def process_user_login(login_id, platform_id, device_token, application_version):
'''
Add or update device and login data. Also deletes oldest device if number of devices exceeds maximum.
'''
with session_scope() as session:
session.execute(text('SELECT process_user_login(:login_id,(:language_id)::int2,\
(:platform_id)::int2,:application_version,\
(:max_devices_per_user)::int2,(:max_users_per_device)::int2)'),
{
'login_id': login_id,
'language_id': language_id,
'platform_id': platform_id,
'device_token': device_token,
'application_version': application_version,
'max_devices_per_user': config.max_devices_per_user,
'max_users_per_device': config.max_users_per_device
})
session.commit()
def upsert_login(login_id, language_id):
'''
Add or update a login entity. Returns new or updated login.
'''
with session_scope() as session:
login = session.query(model.Login).filter(model.Login.id == login_id).one_or_none()
if login is not None:
login.language_id = language_id
else:
login = model.Login(id=login_id, language_id=language_id)
session.add(login)
session.commit()
session.refresh(login)
return login
def upsert_device(login_id, application_version, unregistered_ts=None):
'''
Add or update a device entity. Returns new or updated device with relation to login preloaded.
'''
with session_scope() as session:
login = session.query(model.Login).filter(model.Login.id == login_id).one()
device = session.query(model.Device).\
filter(model.Device.login == login).\
filter(model.Device.platform_id == platform_id).\
filter(func.coalesce(model.Device.device_token_new, model.Device.device_token) == device_token).\
one_or_none()
if device is not None:
device.application_version = application_version
device.unregistered_ts = unregistered_ts
else:
device = model.Device(login=login, platform_id=platform_id, device_token=device_token,
application_version=application_version, unregistered_ts=unregistered_ts)
session.add(device)
session.commit()
session.refresh(device)
session.refresh(device.login)
return device
def upsert_message(message_name, cooldown_ts, trigger_event_id, screen, expiry_millis, priority):
'''
Add or update a message. Returns new or updated message.
'''
with session_scope() as session:
message = session.query(model.Message).filter(model.Message.name == message_name).one_or_none()
if message is not None:
message.cooldown_ts = cooldown_ts
message.trigger_event_id = trigger_event_id
message.screen = screen
message.expiry_millis = expiry_millis
message.priority = priority
else:
message = model.Message(name=message_name, cooldown_ts=cooldown_ts, trigger_event_id=trigger_event_id,
screen=screen, expiry_millis=expiry_millis, priority=priority)
session.add(message)
session.commit()
session.refresh(message)
return message
def add_message(message_name, message_text, trigger_event_id=None, cooldown_ts=None,
screen='', expiry_millis=None, priority=GCM2.PRIORITY_norMAL):
'''
Add or update a message with localization for one language.
'''
message = upsert_message(message_name, priority)
message_localization = upsert_message_localization(message_name, message_text)
return message_localization
def get_and_update_messages_to_send(user_message_set):
'''
Update last time a message id was send for a user.
Expects a set of (login_id,message_id) tuples.
'''
# collect user messages in a dictionary for easier processing
user_dict = defaultdict(set)
for login_id, message_id in user_message_set:
user_dict[login_id].add(message_id)
with session_scope() as session:
joined_login_ids = ','.join([str(login_id) for login_id in user_dict.keys()])
array_login_ids = "'{{{}}}'".format(joined_login_ids)
query = "select * from get_non_elligible_user_message_pairs({})".format(array_login_ids)
non_eligible_messages = session.query(model.UserMessageLastTimeSent).\
from_statement(text(query)).all()
for non_eligible_message in non_eligible_messages:
user_dict[non_eligible_message.login_id].discard(non_eligible_message.message_id)
# update user_message_last_time_sent
return_tuple = []
for user, messages in user_dict.iteritems():
for message in messages:
return_tuple.append({str(user): str(message)})
session.execute(text(
'SELECT upsert_user_message_last_time_sent((:login_id)::bigint,:message_id)'),
{
'login_id': user,
'message_id': message
})
session.commit()
return return_tuple
def _extra_froms(self):
# Todo: this Could be made memoized
# if the memoization is reset on each generative call.
froms = []
seen = set([self.table])
if self._whereclause is not None:
for item in _from_objects(self._whereclause):
if not seen.intersection(item._cloned_set):
froms.append(item)
seen.update(item._cloned_set)
return froms
def _extra_froms(self):
# Todo: this Could be made memoized
# if the memoization is reset on each generative call.
froms = []
seen = set([self.table])
if self._whereclause is not None:
for item in _from_objects(self._whereclause):
if not seen.intersection(item._cloned_set):
froms.append(item)
seen.update(item._cloned_set)
return froms
def _extra_froms(self):
# Todo: this Could be made memoized
# if the memoization is reset on each generative call.
froms = []
seen = set([self.table])
if self._whereclause is not None:
for item in _from_objects(self._whereclause):
if not seen.intersection(item._cloned_set):
froms.append(item)
seen.update(item._cloned_set)
return froms
def start(self):
"""Start the service."""
self._hub.start()
with self.sessionCtx() as s:
stmt = update(db.Microbot).values(is_connected=False)
s.execute(stmt)
self._evtHandle = self._hub.onMicrobot(self._onMbFound, self._onMbLost)
self._daemon.start()
def _extra_froms(self):
# Todo: this Could be made memoized
# if the memoization is reset on each generative call.
froms = []
seen = set([self.table])
if self._whereclause is not None:
for item in _from_objects(self._whereclause):
if not seen.intersection(item._cloned_set):
froms.append(item)
seen.update(item._cloned_set)
return froms
def _extra_froms(self):
# Todo: this Could be made memoized
# if the memoization is reset on each generative call.
froms = []
seen = set([self.table])
if self._whereclause is not None:
for item in _from_objects(self._whereclause):
if not seen.intersection(item._cloned_set):
froms.append(item)
seen.update(item._cloned_set)
return froms
def _params(self, unique, optionaldict, kwargs):
if len(optionaldict) == 1:
kwargs.update(optionaldict[0])
elif len(optionaldict) > 1:
raise exc.ArgumentError(
"params() takes zero or one positional dictionary argument")
def visit_bindparam(bind):
if bind.key in kwargs:
bind.value = kwargs[bind.key]
bind.required = False
if unique:
bind._convert_to_unique()
return cloned_traverse(self, {}, {'bindparam': visit_bindparam})
def proxy_set(self):
s = util.column_set([self])
if hasattr(self, '_proxies'):
for c in self._proxies:
s.update(c.proxy_set)
return s
def update(self, value):
self._data.update(value)
self._all_cols.clear()
self._all_cols.update(self._data.values())
def _populate_column_collection(self):
columns = [c for c in self.left.columns] + \
[c for c in self.right.columns]
self.primary_key.extend(sqlutil.reduce_columns(
(c for c in columns if c.primary_key), self.onclause))
self._columns.update((col._label, col) for col in columns)
self.foreign_keys.update(itertools.chain(
*[col.foreign_keys for col in columns]))
def update(self, whereclause=None, values=None, inline=False, **kwargs):
"""Generate an :func:`.update` construct against this
:class:`.TableClause`.
E.g.::
table.update().where(table.c.id==7).values(name='foo')
See :func:`.update` for argument and usage information.
"""
return update(self, whereclause=whereclause,
values=values, inline=inline, **kwargs)
def _froms(self):
# would love to cache this,
# but there's just enough edge cases,particularly Now that
# declarative encourages construction of sql expressions
# without tables present,to just regen this each time.
froms = []
seen = set()
translate = self._from_cloned
def add(items):
for item in items:
if item is self:
raise exc.InvalidRequestError(
"select() construct refers to itself as a FROM")
if translate and item in translate:
item = translate[item]
if not seen.intersection(item._cloned_set):
froms.append(item)
seen.update(item._cloned_set)
add(_from_objects(*self._raw_columns))
if self._whereclause is not None:
add(_from_objects(self._whereclause))
add(self._from_obj)
return froms
def _extra_froms(self):
# Todo: this Could be made memoized
# if the memoization is reset on each generative call.
froms = []
seen = set([self.table])
if self._whereclause is not None:
for item in _from_objects(self._whereclause):
if not seen.intersection(item._cloned_set):
froms.append(item)
seen.update(item._cloned_set)
return froms
def _extra_froms(self):
# Todo: this Could be made memoized
# if the memoization is reset on each generative call.
froms = []
seen = set([self.table])
if self._whereclause is not None:
for item in _from_objects(self._whereclause):
if not seen.intersection(item._cloned_set):
froms.append(item)
seen.update(item._cloned_set)
return froms
def _extra_froms(self):
# Todo: this Could be made memoized
# if the memoization is reset on each generative call.
froms = []
seen = set([self.table])
if self._whereclause is not None:
for item in _from_objects(self._whereclause):
if not seen.intersection(item._cloned_set):
froms.append(item)
seen.update(item._cloned_set)
return froms
def _extra_froms(self):
# Todo: this Could be made memoized
# if the memoization is reset on each generative call.
froms = []
seen = set([self.table])
if self._whereclause is not None:
for item in _from_objects(self._whereclause):
if not seen.intersection(item._cloned_set):
froms.append(item)
seen.update(item._cloned_set)
return froms
def _extra_froms(self):
# Todo: this Could be made memoized
# if the memoization is reset on each generative call.
froms = []
seen = set([self.table])
if self._whereclause is not None:
for item in _from_objects(self._whereclause):
if not seen.intersection(item._cloned_set):
froms.append(item)
seen.update(item._cloned_set)
return froms
def _extra_froms(self):
# Todo: this Could be made memoized
# if the memoization is reset on each generative call.
froms = []
seen = set([self.table])
if self._whereclause is not None:
for item in _from_objects(self._whereclause):
if not seen.intersection(item._cloned_set):
froms.append(item)
seen.update(item._cloned_set)
return froms
def _extra_froms(self):
# Todo: this Could be made memoized
# if the memoization is reset on each generative call.
froms = []
seen = set([self.table])
if self._whereclause is not None:
for item in _from_objects(self._whereclause):
if not seen.intersection(item._cloned_set):
froms.append(item)
seen.update(item._cloned_set)
return froms