How to use RelStorage - 10 common examples

def __call__(self, uri):
            uri = uri.replace('postgres://', 'http://', 1)
            parsed_uri = urlparse.urlsplit(uri)
            kw = dict(cgi.parse_qsl(parsed_uri.query))

            adapter_factory, kw = self.adapter_helper(parsed_uri, kw)
            kw, unused = self.interpret_kwargs(kw)

            demostorage = kw.pop('demostorage', False)
            options = Options(**kw)

            def factory():
                adapter = adapter_factory(options)
                storage = RelStorage(adapter=adapter, options=options)
                if demostorage:
                    storage = DemoStorage(base=storage)
                return storage
            return factory, unused

def RelStorageConfigurationFactory(key, dbconfig):
    if not RELSTORAGE:
        raise Exception("You must install the relstorage package before you can use "
                        "it as a dabase adapter.")
    config = dbconfig.get('configuration', {})
    options = Options(**dbconfig['options'])
    if dbconfig['type'] == 'postgres':
        from relstorage.adapters.postgresql import PostgreSQLAdapter
        dsn = "dbname={dbname} user={user} host={host} password={password} port={port}".format(**dbconfig['dsn'])  # noqa
        adapter = PostgreSQLAdapter(dsn=dsn, options=options)
    rs = RelStorage(adapter=adapter, options=options)
    db = DB(rs)
    try:
        conn = db.open()
        rootobj = conn.root()
        if not IDatabase.providedBy(rootobj):
            alsoProvides(rootobj, IDatabase)
        transaction.commit()
    except:  # noqa
        pass
    finally:
        rootobj = None

adapter = PostgreSQLAdapter(dsn=dsn, options=options)
    rs = RelStorage(adapter=adapter, options=options)
    db = DB(rs)
    try:
        conn = db.open()
        rootobj = conn.root()
        if not IDatabase.providedBy(rootobj):
            alsoProvides(rootobj, IDatabase)
        transaction.commit()
    except:  # noqa
        pass
    finally:
        rootobj = None
        conn.close()
        db.close()
    rs = RelStorage(adapter=adapter, options=options)
    db = RequestAwareDB(rs, **config)
    return Database(key, db)

def RelStorageConfigurationFactory(key, dbconfig):
    if not RELSTORAGE:
        raise Exception("You must install the relstorage package before you can use "
                        "it as a dabase adapter.")
    config = dbconfig.get('configuration', {})
    options = Options(**dbconfig['options'])
    if dbconfig['type'] == 'postgres':
        from relstorage.adapters.postgresql import PostgreSQLAdapter
        dsn = "dbname={dbname} user={user} host={host} password={password} port={port}".format(**dbconfig['dsn'])  # noqa
        adapter = PostgreSQLAdapter(dsn=dsn, options=options)
    rs = RelStorage(adapter=adapter, options=options)
    db = DB(rs)
    try:
        conn = db.open()
        rootobj = conn.root()
        if not IDatabase.providedBy(rootobj):
            alsoProvides(rootobj, IDatabase)
        transaction.commit()
    except:  # noqa
        pass
    finally:
        rootobj = None
        conn.close()
        db.close()
    rs = RelStorage(adapter=adapter, options=options)
    db = RequestAwareDB(rs, **config)
    return Database(key, db)

def RelStorageConfigurationFactory(key, dbconfig):
    if not RELSTORAGE:
        raise Exception("You must install the relstorage package before you can use "
                        "it as a dabase adapter.")
    config = dbconfig.get('configuration', {})
    options = Options(**dbconfig['options'])
    if dbconfig['type'] == 'postgres':
        from relstorage.adapters.postgresql import PostgreSQLAdapter
        dsn = "dbname={dbname} user={user} host={host} password={password} port={port}".format(**dbconfig['dsn'])  # noqa
        adapter = PostgreSQLAdapter(dsn=dsn, options=options)
    rs = RelStorage(adapter=adapter, options=options)
    db = DB(rs)
    try:
        conn = db.open()
        rootobj = conn.root()
        if not IDatabase.providedBy(rootobj):
            alsoProvides(rootobj, IDatabase)
        transaction.commit()
    except:  # noqa
        pass
    finally:
        rootobj = None
        conn.close()
        db.close()
    rs = RelStorage(adapter=adapter, options=options)
    db = RequestAwareDB(rs, **config)

if options.logging_configuration.upper() in logging_levels:
        logging.basicConfig(level=options.logging_configuration.upper())
    else:
        with open(options.logging_configuration) as f:
            from ZConfig import configureLoggers
            configureLoggers(f.read())

    transform = options.transform
    if transform is not None:
        from .component import global_by_name
        transform = global_by_name(transform)

    jsonifier = Jsonifier(transform=transform)
    driver = relstorage.adapters.postgresql.select_driver(
        relstorage.options.Options(driver=options.driver))
    Binary = driver.Binary
    dsn = options.connection_string
    with closing(pg_connection(dsn)) as conn:
        with closing(conn.cursor()) as cursor:
            if options.nagios:
                if not table_exists(cursor, 'newt_follow_progress'):
                    print("Updater has not run")
                    return 2
                cursor.execute("select max(tid) from object_state")
                [[stid]] = cursor
                utid = follow.get_progress_tid(conn, __name__)
                if stid is None:
                    if utid == -1:
                        print("No transactions")
                        return 0
                    else:

def storage(dsn, keep_history=False, transform=None, auxiliary_tables=(), **kw):
    """Create a RelStorage storage using the newt PostgresQL adapter.

    Keyword options can be used to provide either `ZODB.DB
    `_
    options or `RelStorage
    `_
    options.
    """
    options = relstorage.options.Options(keep_history=keep_history, **kw)
    options.transform = transform
    options.auxiliary_tables = auxiliary_tables
    return relstorage.storage.RelStorage(Adapter(dsn, options), options=options)

def pg_connection(dsn, driver_name='auto'):
    """Create a PostgreSQL (not newt) database connection

    This function should be used rather than, for example, calling
    ``psycopg2.connect``, because it can use other Postgres drivers
    depending on the Python environment and available modules.
    """
    options = relstorage.options.Options(driver=driver_name)
    driver = relstorage.adapters.postgresql.select_driver(options)
    return driver.connect(dsn)

def storage(dsn, keep_history=False, transform=None, auxiliary_tables=(), **kw):
    """Create a RelStorage storage using the newt PostgresQL adapter.

    Keyword options can be used to provide either `ZODB.DB
    `_
    options or `RelStorage
    `_
    options.
    """
    options = relstorage.options.Options(keep_history=keep_history, **kw)
    options.transform = transform
    options.auxiliary_tables = auxiliary_tables
    return relstorage.storage.RelStorage(Adapter(dsn, options), options=options)

# Monkey patches, ook
def _ex_cursor(self, name=None):
    if self._stale_error is not None:
        raise self._stale_error

    with self._lock:
        self._before_load()
        return self._load_conn.cursor(name)

relstorage.storage.RelStorage.ex_cursor = _ex_cursor

def _ex_connect(self):
    return self._adapter.connmanager.open()

relstorage.storage.RelStorage.ex_connect = _ex_connect

def _ex_get(self, oid, ghost_pickle):
    """Return the persistent object with oid 'oid'."""
    if self.opened is None:
        raise ConnectionStateError("The database connection is closed")

    obj = self._cache.get(oid, None)
    if obj is not None:
        return obj
    obj = self._added.get(oid, None)
    if obj is not None:
        return obj
    obj = self._pre_cache.get(oid, None)
    if obj is not None:
        return obj