engine = create_engine(db_url)  Session = sessionmaker(bind=engine)  session = Session()
session.query(xxx)

def apply_driver_hacks(self, app, sa_url, options):          """This method is called before engine creation and used to inject          driver specific hacks into the options.  The `options` parameter is          a dictionary of keyword arguments that will then be used to call          the :func:`sqlalchemy.create_engine` function.          The default implementation provides some saner defaults for things          like pool sizes for MySQL and sqlite.  Also it injects the setting of          `SQLALCHEMY_NATIVE_UNICODE`.          """          if sa_url.drivername.startswith('mysql'):              sa_url.query.setdefault('charset', 'utf8')              if sa_url.drivername != 'mysql+gaerdbms':                  options.setdefault('pool_size', 10)                  options.setdefault('pool_recycle', 7200)　　# 默認7200秒刷新連接          elif sa_url.drivername == 'sqlite':              pool_size = options.get('pool_size')              detected_in_memory = False              if sa_url.database in (None, '', ':memory:'):                  detected_in_memory = True                  from sqlalchemy.pool import StaticPool                  options['poolclass'] = StaticPool                  if 'connect_args' not in options:                      options['connect_args'] = {}                  options['connect_args']['check_same_thread'] = False                    # we go to memory and the pool size was explicitly set                  # to 0 which is fail.  Let the user know that                  if pool_size == 0:                      raise RuntimeError('SQLite in memory database with an '                                         'empty queue not possible due to data '                                         'loss.')              # if pool size is None or explicitly set to 0 we assume the              # user did not want a queue for this sqlite connection and              # hook in the null pool.              elif not pool_size:                  from sqlalchemy.pool import NullPool                  options['poolclass'] = NullPool                # if it's not an in memory database we make the path absolute.              if not detected_in_memory:                  sa_url.database = os.path.join(app.root_path, sa_url.database)            unu = app.config['SQLALCHEMY_NATIVE_UNICODE']          if unu is None:              unu = self.use_native_unicode          if not unu:              options['use_native_unicode'] = False            if app.config['SQLALCHEMY_NATIVE_UNICODE'] is not None:              warnings.warn(                  "The 'SQLALCHEMY_NATIVE_UNICODE' config option is deprecated and will be removed in"                  " v3.0.  Use 'SQLALCHEMY_ENGINE_OPTIONS' instead.",                  DeprecationWarning              )          if not self.use_native_unicode:              warnings.warn(                  "'use_native_unicode' is deprecated and will be removed in v3.0."                  "  Use the 'engine_options' parameter instead.",                  DeprecationWarning              )  

def create_scoped_session(self, options=None):          """Create a :class:`~sqlalchemy.orm.scoping.scoped_session`          on the factory from :meth:`create_session`.          An extra key ``'scopefunc'`` can be set on the ``options`` dict to          specify a custom scope function.  If it's not provided, Flask's app          context stack identity is used. This will ensure that sessions are          created and removed with the request/response cycle, and should be fine          in most cases.          :param options: dict of keyword arguments passed to session class  in              ``create_session``          """            if options is None:              options = {}            scopefunc = options.pop('scopefunc', _app_ctx_stack.__ident_func__)          options.setdefault('query_cls', self.Query)          return orm.scoped_session(              self.create_session(options), scopefunc=scopefunc          )        def create_session(self, options):          """Create the session factory used by :meth:`create_scoped_session`.          The factory **must** return an object that SQLAlchemy recognizes as a session,          or registering session events may raise an exception.          Valid factories include a :class:`~sqlalchemy.orm.session.Session`          class or a :class:`~sqlalchemy.orm.session.sessionmaker`.          The default implementation creates a ``sessionmaker`` for :class:`SignallingSession`.          :param options: dict of keyword arguments passed to session class          """            return orm.sessionmaker(class_=SignallingSession, db=self, **options)  

app = Flask()  db = Sqlalchemy()  db.init_app(app)  ...  ...  db.get_engine(app=app).dispose()　　# 先銷毀已有的engine，確保父進程沒有資料庫連接  ...  ...  fork()    # 派生子進程

# 例如
tornado.start()　　# 啟動多個web實例進程