def get_bind(self, mapper, clause=None):
binding_key = self.__find_binding_key(mapper)
if binding_key is None:
return BaseSignallingSession.get_bind(self, mapper, clause)
else:
state = get_state(self.app)
return state.db.get_engine(self.app, bind=binding_key)
def get_bind(self, mapper=None, clause=None):
# 被操作对象的包名
full_class_name = "%s.%s" % (
mapper.class_.__module__,
mapper.class_.__name__
)
try:
state = get_state(self.app)
except (AssertionError, AttributeError, TypeError) as err:
db_logger.warning(
"cant get configuration. default bind. Error:" + err)
return orm.Session.get_bind(self, mapper, clause)
"""
If there are no binds configured, connect using the default
SQLALCHEMY_DATABASE_URI
"""
if state is None or not self.app.config['SQLALCHEMY_BINDS']:
if not self.app.debug:
db_logger.debug("Connecting -> DEFAULT")
return orm.Session.get_bind(self, mapper, clause)
elif self._name:
db_logger.debug("Connecting -> {}".format(self._name))
return state.db.get_engine(self.app, bind=self._name)
# 写入请求使用 master
# 操作被改动过的对象，也使用 master
elif self._flushing or self._model_changes.get(full_class_name):
bind_key = getattr(mapper.class_, "__bind_key__", "default")
self._model_changes[full_class_name] = True
if self.app.debug:
action = 'WRITE' if self._flushing else 'READ'
db_logger.debug(
"Connecting -> %s MASTER( %s - %s )" % (
action,
mapper.class_,
bind_key
)
)
return state.db.get_engine(self.app, bind=bind_key)
# 其他请求使用 slave
else:
bind_key = getattr(mapper.class_, "__bind_key__", "default")
slave_bind_key = "%s_slave" % bind_key
if slave_bind_key in self.app.config['SQLALCHEMY_BINDS']:
bind_key = slave_bind_key
if self.app.debug:
db_logger.debug(
"Connecting -> READ SLAVE( %s - %s )" % (
mapper.class_, bind_key
)
)
return state.db.get_engine(self.app, bind=bind_key)
def test_connector_cache(app):
db = fsa.SQLAlchemy()
db.init_app(app)
with app.app_context():
db.get_engine()
connector = fsa.get_state(app).connectors[None]
assert connector._app is app
def get_bind(self, mapper=None, clause=None):
"""
获取数据库绑定
"""
# For test
print('Calling get_bind: _name={}'.format(self._name))
state = get_state(self.app)
if self._name:
# 指定
print('Using DB bind: _name={}'.format(self._name))
return state.db.get_engine(self.app, bind=self._name)
else:
# 默认数据库
print('Using default DB bind: _name={}'.format(
state.db.default_bind))
return state.db.get_engine(self.app, bind=state.db.default_bind)
def get_bind(self, mapper=None, clause=None):
try:
state = get_state(self.app)
except (AssertionError, AttributeError, TypeError) as err:
current_app.logger.info(
'cant get configuration. default bind. Error:' + err)
return orm.Session.get_bind(self, mapper, clause)
# If there are no binds configured, use default SQLALCHEMY_DATABASE_URI
if not state or not self.app.config['SQLALCHEMY_BINDS']:
return orm.Session.get_bind(self, mapper, clause)
# if want to user exact bind
if self._bind_name:
return state.db.get_engine(self.app, bind=self._bind_name)
else:
# if no bind is used connect to default
return orm.Session.get_bind(self, mapper, clause)
def get_bind(self, mapper=None, clause=None):
"""Return the engine or connection for a given model or
table, using the ``__bind_key__`` if it is set.
"""
# mapper is None if someone tries to just get a connection
if mapper is not None:
try:
# SA >= 1.3
persist_selectable = mapper.persist_selectable
except AttributeError:
# SA < 1.3
persist_selectable = mapper.mapped_table
info = getattr(persist_selectable, 'info', {})
bind_key = self.bind_key if self.bind_key else info.get('bind_key')
if bind_key is not None:
state = get_state(self.app)
return state.db.get_engine(self.app, bind=bind_key)
return SessionBase.get_bind(self, mapper, clause)
def available_update(self):
from .models import AstronomerAvailableVersion
session = get_state(app=current_app).db.session
available_releases = session.query(AstronomerAvailableVersion).filter(
AstronomerAvailableVersion.hidden_from_ui.is_(False))
for rel in sorted(available_releases,
key=lambda v: version.parse(v.version),
reverse=True):
# For simplicity in the UI, only show the latest version that is available
return {
'level': rel.level,
'date_released': rel.date_released,
'description': rel.description,
'version': rel.version,
'url': rel.url,
}
return None
def get_bind(self, mapper=None, *args, **kwargs):
"""Return the engine or connection for a given model or
table, using the ``__bind_key__`` if it is set.
Patch from https://github.com/pallets/flask-sqlalchemy/pull/1001
"""
# mapper is None if someone tries to just get a connection
if mapper is not None:
try:
# SA >= 1.3
persist_selectable = mapper.persist_selectable
except AttributeError:
# SA < 1.3
persist_selectable = mapper.mapped_table
info = getattr(persist_selectable, "info", {})
bind_key = info.get("bind_key")
if bind_key is not None:
state = get_state(self.app)
return state.db.get_engine(self.app, bind=bind_key)
return SessionBase.get_bind(self, mapper, *args, **kwargs)
def generate_random_data(count):
db = flask_sqlalchemy.get_state(current_app).db
User.query.delete(synchronize_session='evaluate')
for x in range(count):
p = Person(locales.EN)
date_created = datetime.datetime.now() - datetime.timedelta(
days=p.work_experience() * 365)
user = User(email=p.email(),
password="******",
date_created=date_created)
user.set_password(user.password)
db.session.add(user)
print_progress_bar(x + 1,
count,
prefix='Progress:',
suffix='Complete',
length=50)
if x % 10 == 0:
db.session.commit()
db.session.commit()
def _get_session():
return get_state(current_app).db.session
def _get_session():
return get_state(current_app).db.session
def save(model):
session = get_state(current_app).db.session
session.add(model)
session.commit()
def session(self):
db = get_state(self.app).db
return db.session
