Python peewee.SqliteDatabase方法代码示例

# 需要导入模块: import peewee [as 别名]
# 或者: from peewee import SqliteDatabase [as 别名]
def apply_migration(step):
    import peewee
    import playhouse.migrate
    from hotline.database import models

    migrations_module = importlib.import_module(
        f".{step}", package="hotline.database.migrations"
    )

    if isinstance(models.db.obj, peewee.SqliteDatabase):
        migrator = playhouse.migrate.SqliteMigrator(models.db)
    else:
        migrator = playhouse.migrate.PostgresqlMigrator(models.db)

    migrations = migrations_module.migrate(migrator)

    print(f"The following migrations are about to be applied to {models.db.obj}:")
    for migration in migrations:
        print(" * ", migration.method, migration.args)

    input("Press enter to continue.")

    playhouse.migrate.migrate(*migrations)

    print("Done.") 

# 需要导入模块: import peewee [as 别名]
# 或者: from peewee import SqliteDatabase [as 别名]
def create_db_connection():
    """ Creates a database connection with the postgres db"""

    is_test_env = os.getenv('MQTT_PWN_TESTING_ENV')

    if is_test_env:
        db = SqliteDatabase(':memory:')
    else:
        db = PostgresqlDatabase(
            config.DB_NAME,
            user=config.DB_USER,
            password=config.DB_PASSWORD,
            host=config.DB_HOST,
            port=config.DB_PORT
        )

    database_proxy.initialize(db)

    return db 

# 需要导入模块: import peewee [as 别名]
# 或者: from peewee import SqliteDatabase [as 别名]
def change_license_field_type(migrator, db):
    if isinstance(db, peewee.SqliteDatabase):
        # SQLite has not length
        return

    try:
        migrate(migrator.drop_column('packageversion', 'license_old'))
    except:
        pass

    with db.transaction():
        migrate(
            migrator.rename_column('packageversion', 'license', 'license_old'),
            migrator.add_column("packageversion", 'license', PackageVersion.license),
        )

        db.execute_sql("UPDATE packageversion SET license = license_old")
        migrate(migrator.drop_column('packageversion', 'license_old')) 

# 需要导入模块: import peewee [as 别名]
# 或者: from peewee import SqliteDatabase [as 别名]
def __init__(self, data_model):
        self.data_model = data_model
        self.data_model.fake_item_ids_store = self

        assert self.data_model.cache_dir, "FakeItemIds need cache_dir from data_model!"
        sqlite_path = os.path.join(self.data_model.cache_dir, "fake_item_ids_store.db")

        sqlite_database = SqliteDatabase(sqlite_path, check_same_thread=False)

        class FakeItemIdsStore(Model):
            is_deleted = BooleanField(default=False)  # mark processed or duplicated items
            item_id = CharField()
            item_content_json = TextField()
            created_at = TimeField(default=datetime.datetime.now)

            class Meta:
                database = sqlite_database
        self.storage = FakeItemIdsStore

        if not self.storage.table_exists():
            self.storage.create_table()
            sqlite_database.create_index(self.storage, "is_deleted item_id".split(" ")) 

# 需要导入模块: import peewee [as 别名]
# 或者: from peewee import SqliteDatabase [as 别名]
def db():
    return pw.SqliteDatabase(':memory:') 

# 需要导入模块: import peewee [as 别名]
# 或者: from peewee import SqliteDatabase [as 别名]
def __init__(self):
        self.path = None
        self.db = SqliteDatabase(None) 

# 需要导入模块: import peewee [as 别名]
# 或者: from peewee import SqliteDatabase [as 别名]
def main():

    # Init database
    dbpath = os.path.join(SETTINGS_DIR, "settings.db")
    print("Using database " + dbpath)
    sqlite_db = peewee.SqliteDatabase(dbpath)
    init_db(sqlite_db)

    app = RestaticApp(sys.argv, single_app=True)
    app.updater = get_updater()
    sys.exit(app.exec_()) 

# 需要导入模块: import peewee [as 别名]
# 或者: from peewee import SqliteDatabase [as 别名]
def app(tmpdir, qtbot):
    tmp_db = tmpdir.join("settings.sqlite")
    mock_db = peewee.SqliteDatabase(str(tmp_db))
    restatic.models.init_db(mock_db)
    app = RestaticApp([])
    qtbot.addWidget(app.main_window)
    return app 

# 需要导入模块: import peewee [as 别名]
# 或者: from peewee import SqliteDatabase [as 别名]
def get_db_conn():
    import peewee
    env = os.environ.get('SENTINEL_ENV', 'production')

    # default values should be used unless you need a different config for development
    db_host = sentinel_cfg.get('db_host', '127.0.0.1')
    db_port = sentinel_cfg.get('db_port', None)
    db_name = sentinel_cfg.get('db_name', 'sentinel')
    db_user = sentinel_cfg.get('db_user', 'sentinel')
    db_password = sentinel_cfg.get('db_password', 'sentinel')
    db_charset = sentinel_cfg.get('db_charset', 'utf8mb4')
    db_driver = sentinel_cfg.get('db_driver', 'sqlite')

    if (env == 'test'):
        if db_driver == 'sqlite':
            db_name = sqlite_test_db_name(db_name)
        else:
            db_name = "%s_test" % db_name

    peewee_drivers = {
        'mysql': peewee.MySQLDatabase,
        'postgres': peewee.PostgresqlDatabase,
        'sqlite': peewee.SqliteDatabase,
    }
    driver = peewee_drivers.get(db_driver)

    dbpfn = 'passwd' if db_driver == 'mysql' else 'password'
    db_conn = {
        'host': db_host,
        'user': db_user,
        dbpfn: db_password,
    }
    if db_port:
        db_conn['port'] = int(db_port)

    if driver == peewee.SqliteDatabase:
        db_conn = {}

    db = driver(db_name, **db_conn)

    return db 

# 需要导入模块: import peewee [as 别名]
# 或者: from peewee import SqliteDatabase [as 别名]
def __init__(self, *_, **__):
        super(SqliteDatabase, self).__init__(*_, **__) 

# 需要导入模块: import peewee [as 别名]
# 或者: from peewee import SqliteDatabase [as 别名]
def _create_database(self):
        return SqliteDatabase(
            self.database_path, pragmas={"foreign_keys": 1, "secure_delete": 1}
        ) 

# 需要导入模块: import peewee [as 别名]
# 或者: from peewee import SqliteDatabase [as 别名]
def init_sqlite(url):
    global DB

    dbfile = os.path.join("/", *url.path.split("/"))
    dirname = os.path.dirname(dbfile)

    log.info('Opening sqlite database: %s', dbfile)

    if not os.path.exists(dirname):
        os.makedirs(dirname)

    DB.initialize(SqliteDatabase(dbfile))
    log.info("Database initialized as '%s'. Checking migrations...", dbfile)
    return DB, SqliteMigrator(DB) 

# 需要导入模块: import peewee [as 别名]
# 或者: from peewee import SqliteDatabase [as 别名]
def main():
    args = parse_args()
    signal.signal(signal.SIGINT, signal.SIG_DFL)  # catch ctrl-c and exit

    want_version = getattr(args, 'version', False)
    want_background = getattr(args, 'daemonize', False)

    if want_version:
        print(f"Vorta {__version__}")
        sys.exit()

    if want_background:
        if os.fork():
            sys.exit()

    init_logger(background=want_background)

    # Init database
    sqlite_db = peewee.SqliteDatabase(os.path.join(SETTINGS_DIR, 'settings.db'))
    init_db(sqlite_db)

    # Init app after database is available
    from vorta.application import VortaApp
    app = VortaApp(sys.argv, single_app=True)
    app.updater = get_updater()

    sys.exit(app.exec_()) 

# 需要导入模块: import peewee [as 别名]
# 或者: from peewee import SqliteDatabase [as 别名]
def qapp(tmpdir_factory, local_en):
    tmp_db = tmpdir_factory.mktemp('Vorta').join('settings.sqlite')
    mock_db = peewee.SqliteDatabase(str(tmp_db))
    vorta.models.init_db(mock_db)

    from vorta.application import VortaApp
    VortaApp.set_borg_details_action = MagicMock()  # Can't use pytest-mock in session scope
    VortaApp.scheduler = MagicMock()

    qapp = VortaApp([])  # Only init QApplication once to avoid segfaults while testing.

    yield qapp 

# 需要导入模块: import peewee [as 别名]
# 或者: from peewee import SqliteDatabase [as 别名]
def get_database(self):
        """Returns the correct database driver

        Returns:
            :obj:`pw.Database`
        Raises:
            AttributeError: if `--username` or `--password` not passed
                (if `--dbtype [postgres|mysql]`)

        """
        if self.get('dbtype') == 'sqlite':
            return pw.SqliteDatabase(self.get('dbname'),
                                     pragmas={'journal_mode': 'wal',
                                              'cache_size': -1 * 64000})
        else:
            if self.get('username') is None or self.get('password') is None:
                raise AttributeError('[ERROR] dbtype %s requires username and'
                                     ' password.\n' % str(self.get('dbtype')))
            if self.get('hostname') is None:
                self.set('hostname', 'localhost')
            if self.get('dbtype') == 'mysql':
                if self.get('port') is None or self.get('port') == '':
                    self.set('port', str(3306))
                return pw.MySQLDatabase(
                    self.get('dbname'),
                    user=self.get('username'),
                    password=self.get('password'),
                    host=self.get('hostname'),
                    port=int(self.get('port')))
            elif self.get('dbtype') == 'postgres':
                if self.get('port') is None or self.get('port') == '':
                    self.set('port', str(5432))
                return pw.PostgresqlDatabase(
                    self.get('dbname'),
                    user=self.get('username'),
                    password=self.get('password'),
                    host=self.get('hostname'),
                    port=int(self.get('port')))